@event-driven-io/dumbo 0.13.0-beta.40 → 0.13.0-beta.42

package/dist/{core-BG__WVn6.js → core-IV7or0Mj.js}

@@ -1,2262 +1,2278 @@
-import ansis from "ansis";
 import { v7 } from "uuid";
+import ansis from "ansis";
 
-//#region src/core/schema/schemaComponent.ts
-const schemaComponent = (key, options) => {
-	const componentsMap = new Map(options.components?.map((comp) => [comp.schemaComponentKey, comp]));
-	const migrations = [...options.migrations ?? []];
-	return {
-		schemaComponentKey: key,
-		components: componentsMap,
-		get migrations() {
-			return [...migrations, ...Array.from(componentsMap.values()).flatMap((c) => c.migrations)];
-		},
-		addComponent: (component) => {
-			componentsMap.set(component.schemaComponentKey, component);
-			migrations.push(...component.migrations);
-			return component;
-		},
-		addMigration: (migration) => {
-			migrations.push(migration);
-		}
-	};
+//#region src/core/errors/index.ts
+const isNumber = (val) => typeof val === "number" && val === val;
+const isString = (val) => typeof val === "string";
+var DumboError = class DumboError extends Error {
+	static ErrorCode = 500;
+	static ErrorType = "DumboError";
+	errorCode;
+	errorType;
+	innerError;
+	constructor(options) {
+		const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : DumboError.ErrorCode;
+		const errorType = options && typeof options === "object" && "errorType" in options ? options.errorType ?? DumboError.ErrorType : DumboError.ErrorType;
+		const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during DumboError processing`;
+		const innerError = options && typeof options === "object" && "innerError" in options ? options.innerError : void 0;
+		super(message, { cause: innerError });
+		this.errorCode = errorCode;
+		this.errorType = errorType;
+		this.innerError = innerError;
+		Object.setPrototypeOf(this, DumboError.prototype);
+	}
+	static isInstanceOf(error, options) {
+		if (typeof error !== "object" || error === null || !("errorCode" in error) || !isNumber(error.errorCode) || !("errorType" in error) || !isString(error.errorType)) return false;
+		if (!options) return true;
+		if (options.errorCode !== void 0 && error.errorCode !== options.errorCode) return false;
+		if (options.errorType !== void 0 && error.errorType !== options.errorType) return false;
+		return true;
+	}
 };
-const isSchemaComponentOfType = (component, prefix) => component.schemaComponentKey.startsWith(prefix);
-const filterSchemaComponentsOfType = (components, prefix) => mapSchemaComponentsOfType(components, prefix);
-const mapSchemaComponentsOfType = (components, prefix, keyMapper) => new Map(Array.from(components.entries()).filter(([urn]) => urn.startsWith(prefix)).map(([urn, component]) => [keyMapper ? keyMapper(component) : urn, component]));
-const findSchemaComponentsOfType = (root, prefix) => {
-	const results = [];
-	const traverse = (component) => {
-		if (component.schemaComponentKey.startsWith(prefix)) results.push(component);
-		for (const child of component.components.values()) traverse(child);
-	};
-	traverse(root);
-	return results;
+var ConcurrencyError = class ConcurrencyError extends DumboError {
+	static ErrorCode = 412;
+	static ErrorType = "ConcurrencyError";
+	constructor(message, innerError) {
+		super({
+			errorCode: ConcurrencyError.ErrorCode,
+			errorType: ConcurrencyError.ErrorType,
+			message: message ?? `Expected document state does not match current one!`,
+			innerError
+		});
+		Object.setPrototypeOf(this, ConcurrencyError.prototype);
+	}
 };
-
-//#endregion
-//#region src/core/schema/components/columnSchemaComponent.ts
-const ColumnURNType = "sc:dumbo:column";
-const ColumnURN = ({ name }) => `${ColumnURNType}:${name}`;
-const columnSchemaComponent = (params) => {
-	const { columnName, type, notNull, unique, primaryKey, default: defaultValue, ...schemaOptions } = params;
-	return {
-		...schemaComponent(ColumnURN({ name: columnName }), schemaOptions),
-		columnName,
-		notNull,
-		unique,
-		primaryKey,
-		defaultValue,
-		sqlTokenType: "SQL_COLUMN",
-		name: columnName,
-		type
-	};
+var TransientDatabaseError = class TransientDatabaseError extends DumboError {
+	static ErrorCode = 503;
+	static ErrorType = "TransientDatabaseError";
+	constructor(message, innerError) {
+		super({
+			errorCode: TransientDatabaseError.ErrorCode,
+			errorType: TransientDatabaseError.ErrorType,
+			message: message ?? `A transient error occurred during database operation. Retrying the operation might succeed.`,
+			innerError
+		});
+		Object.setPrototypeOf(this, TransientDatabaseError.prototype);
+	}
 };
-
-//#endregion
-//#region src/core/schema/components/indexSchemaComponent.ts
-const IndexURNType = "sc:dumbo:index";
-const IndexURN = ({ name }) => `${IndexURNType}:${name}`;
-const indexSchemaComponent = ({ indexName, columnNames, isUnique, ...migrationsOrComponents }) => {
-	return {
-		...schemaComponent(IndexURN({ name: indexName }), {
-			migrations: migrationsOrComponents.migrations ?? [],
-			components: [...migrationsOrComponents.components ?? []]
-		}),
-		indexName,
-		get columnNames() {
-			return columnNames;
-		},
-		addColumn: (column) => columnNames.push(typeof column === "string" ? column : column.columnName),
-		isUnique
-	};
+var ConnectionError = class ConnectionError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "ConnectionError";
+	constructor(message, innerError) {
+		super(message ?? `A connection error occurred during database operation.`, innerError);
+		this.errorType = ConnectionError.ErrorType;
+		Object.setPrototypeOf(this, ConnectionError.prototype);
+	}
 };
-
-//#endregion
-//#region src/core/schema/components/tableSchemaComponent.ts
-const TableURNType = "sc:dumbo:table";
-const TableURN = ({ name }) => `${TableURNType}:${name}`;
-const tableSchemaComponent = ({ tableName, columns, primaryKey, relationships, ...migrationsOrComponents }) => {
-	columns ??= {};
-	relationships ??= {};
-	const base = schemaComponent(TableURN({ name: tableName }), {
-		migrations: migrationsOrComponents.migrations ?? [],
-		components: [...migrationsOrComponents.components ?? [], ...Object.values(columns)]
-	});
-	return {
-		...base,
-		tableName,
-		primaryKey: primaryKey ?? [],
-		relationships,
-		get columns() {
-			const columnsMap = mapSchemaComponentsOfType(base.components, ColumnURNType, (c) => c.columnName);
-			return Object.assign(columnsMap, columns);
-		},
-		get indexes() {
-			return mapSchemaComponentsOfType(base.components, IndexURNType, (c) => c.indexName);
-		},
-		addColumn: (column) => base.addComponent(column),
-		addIndex: (index) => base.addComponent(index)
-	};
+var SerializationError = class SerializationError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "SerializationError";
+	constructor(message, innerError) {
+		super(message ?? `A serialization failure occurred. The transaction can be retried.`, innerError);
+		this.errorType = SerializationError.ErrorType;
+		Object.setPrototypeOf(this, SerializationError.prototype);
+	}
 };
-
-//#endregion
-//#region src/core/schema/components/databaseSchemaSchemaComponent.ts
-const DatabaseSchemaURNType = "sc:dumbo:database_schema";
-const DatabaseSchemaURN = ({ name }) => `${DatabaseSchemaURNType}:${name}`;
-const databaseSchemaSchemaComponent = ({ schemaName, tables, ...migrationsOrComponents }) => {
-	const base = schemaComponent(DatabaseSchemaURN({ name: schemaName }), {
-		migrations: migrationsOrComponents.migrations ?? [],
-		components: [...migrationsOrComponents.components ?? [], ...Object.values(tables ?? {})]
-	});
-	return {
-		...base,
-		schemaName,
-		get tables() {
-			const tablesMap = mapSchemaComponentsOfType(base.components, TableURNType, (c) => c.tableName);
-			return Object.assign(tablesMap, tables);
-		},
-		addTable: (table) => base.addComponent(typeof table === "string" ? tableSchemaComponent({ tableName: table }) : table)
-	};
+var DeadlockError = class DeadlockError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "DeadlockError";
+	constructor(message, innerError) {
+		super(message ?? `A deadlock was detected. The transaction can be retried.`, innerError);
+		this.errorType = DeadlockError.ErrorType;
+		Object.setPrototypeOf(this, DeadlockError.prototype);
+	}
 };
-
-//#endregion
-//#region src/core/schema/components/databaseSchemaComponent.ts
-const DatabaseURNType = "sc:dumbo:database";
-const DatabaseURN = ({ name }) => `${DatabaseURNType}:${name}`;
-const databaseSchemaComponent = ({ databaseName, schemas, ...migrationsOrComponents }) => {
-	schemas ??= {};
-	const base = schemaComponent(DatabaseURN({ name: databaseName }), {
-		migrations: migrationsOrComponents.migrations ?? [],
-		components: [...migrationsOrComponents.components ?? [], ...Object.values(schemas)]
-	});
-	return {
-		...base,
-		databaseName,
-		get schemas() {
-			const schemasMap = mapSchemaComponentsOfType(base.components, DatabaseSchemaURNType, (c) => c.schemaName);
-			return Object.assign(schemasMap, schemas);
-		},
-		addSchema: (schema) => base.addComponent(typeof schema === "string" ? databaseSchemaSchemaComponent({ schemaName: schema }) : schema)
-	};
+var LockNotAvailableError = class LockNotAvailableError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "LockNotAvailableError";
+	constructor(message, innerError) {
+		super(message ?? `The requested lock is not available.`, innerError);
+		this.errorType = LockNotAvailableError.ErrorType;
+		Object.setPrototypeOf(this, LockNotAvailableError.prototype);
+	}
 };
-
-//#endregion
-//#region src/core/schema/components/index.ts
-const schemaComponentURN = {
-	database: DatabaseURN,
-	schema: DatabaseSchemaURN,
-	table: TableURN,
-	column: ColumnURN,
-	index: IndexURN,
-	extractName: (urn) => {
-		const parts = urn.split(":");
-		return parts[parts.length - 1] || "";
+var InsufficientResourcesError = class InsufficientResourcesError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "InsufficientResourcesError";
+	constructor(message, innerError) {
+		super(message ?? `Insufficient resources to complete the database operation (e.g. disk full, out of memory, too many connections).`, innerError);
+		this.errorType = InsufficientResourcesError.ErrorType;
+		Object.setPrototypeOf(this, InsufficientResourcesError.prototype);
 	}
 };
-
-//#endregion
-//#region src/core/drivers/databaseDriver.ts
-const canHandleDriverWithConnectionString = (driver, tryParseConnectionString) => (options) => {
-	if ("driverType" in options) return options.driverType === driver;
-	if ("connectionString" in options && typeof options.connectionString === "string") return tryParseConnectionString(options.connectionString) !== null;
-	return false;
+var SystemError = class SystemError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "SystemError";
+	constructor(message, innerError) {
+		super(message ?? `A system-level error occurred (e.g. I/O error).`, innerError);
+		this.errorType = SystemError.ErrorType;
+		Object.setPrototypeOf(this, SystemError.prototype);
+	}
 };
-const DumboDatabaseDriverRegistry = () => {
-	const drivers = /* @__PURE__ */ new Map();
-	const register = (driverType, plugin) => {
-		const entry = drivers.get(driverType);
-		if (entry && (typeof entry !== "function" || typeof plugin === "function")) return;
-		drivers.set(driverType, plugin);
-	};
-	const getDriver = (options) => options.driverType ? drivers.get(options.driverType) : [...drivers.values()].find((d) => typeof d !== "function" && d.canHandle(options));
-	const tryResolve = async (options) => {
-		const driver = getDriver(options);
-		if (!driver) return null;
-		if (typeof driver !== "function") return driver;
-		const plugin = await driver();
-		register(plugin.driverType, plugin);
-		return plugin;
-	};
-	const tryGet = (options) => {
-		const driver = getDriver(options);
-		return driver && typeof driver !== "function" ? driver : null;
-	};
-	const has = (driverType) => drivers.has(driverType);
-	return {
-		register,
-		tryResolve,
-		tryGet,
-		has,
-		get databaseDriverTypes() {
-			return Array.from(drivers.keys());
-		}
-	};
-};
-const dumboDatabaseDriverRegistry = globalThis.dumboDatabaseDriverRegistry = globalThis.dumboDatabaseDriverRegistry ?? DumboDatabaseDriverRegistry();
-
-//#endregion
-//#region src/core/drivers/index.ts
-/**
-* Accepts a `databaseType` (e.g. PostgreSQL, SQLite) and a `driverName`
-* (the library name, e.g. pg, sqlite3) and combines them to a singular
-* `databaseDriverType` which can be used in database handling.
-*/
-function toDatabaseDriverType(databaseType, driverName) {
-	return `${databaseType}:${driverName}`;
-}
-/**
-* Accepts a fully formatted `driverType` and returns the broken down
-* `databaseType` and `driverName`.
-*/
-function fromDatabaseDriverType(databaseDriverType) {
-	const parts = databaseDriverType.split(":");
-	return {
-		databaseType: parts[0],
-		driverName: parts[1]
-	};
-}
-/**
-* Accepts a fully formatted `databaseDriverType` and returns the `driverName`.
-*/
-function getDatabaseDriverName(databaseDriverType) {
-	const { driverName } = fromDatabaseDriverType(databaseDriverType);
-	return driverName;
-}
-/**
-* Accepts a fully formatted `databaseDriverType` and returns the `databaseType`.
-*/
-function getDatabaseType(databaseDriverType) {
-	const { databaseType } = fromDatabaseDriverType(databaseDriverType);
-	return databaseType;
-}
-
-//#endregion
-//#region src/core/schema/databaseMetadata/databaseMetadata.ts
-const DumboDatabaseMetadataRegistry = () => {
-	const infos = /* @__PURE__ */ new Map();
-	const register = (databaseType, info) => {
-		const entry = infos.get(databaseType);
-		if (entry && (typeof entry !== "function" || typeof info === "function")) return;
-		infos.set(databaseType, info);
-	};
-	const tryResolve = async (databaseType) => {
-		const entry = infos.get(databaseType);
-		if (!entry) return null;
-		if (typeof entry !== "function") return entry;
-		const resolved = await entry();
-		register(databaseType, resolved);
-		return resolved;
-	};
-	const tryGet = (databaseType) => {
-		const entry = infos.get(databaseType);
-		return entry && typeof entry !== "function" ? entry : null;
-	};
-	const has = (databaseType) => infos.has(databaseType);
-	return {
-		register,
-		tryResolve,
-		tryGet,
-		has,
-		get databaseTypes() {
-			return Array.from(infos.keys());
-		}
-	};
+var AdminShutdownError = class AdminShutdownError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "AdminShutdownError";
+	constructor(message, innerError) {
+		super(message ?? `The database server is shutting down or restarting.`, innerError);
+		this.errorType = AdminShutdownError.ErrorType;
+		Object.setPrototypeOf(this, AdminShutdownError.prototype);
+	}
 };
-const dumboDatabaseMetadataRegistry = globalThis.dumboDatabaseMetadataRegistry = globalThis.dumboDatabaseMetadataRegistry ?? DumboDatabaseMetadataRegistry();
-const getDatabaseMetadata = (driverType) => {
-	const { databaseType } = fromDatabaseDriverType(driverType);
-	return dumboDatabaseMetadataRegistry.tryGet(databaseType);
+var QueryCanceledError = class QueryCanceledError extends TransientDatabaseError {
+	static ErrorCode = 503;
+	static ErrorType = "QueryCanceledError";
+	constructor(message, innerError) {
+		super(message ?? `The query was canceled, e.g. due to statement timeout or user request.`, innerError);
+		this.errorType = QueryCanceledError.ErrorType;
+		Object.setPrototypeOf(this, QueryCanceledError.prototype);
+	}
 };
-const resolveDatabaseMetadata = async (driverType, driverOverride) => {
-	if (driverOverride) return driverOverride;
-	const { databaseType } = fromDatabaseDriverType(driverType);
-	return dumboDatabaseMetadataRegistry.tryResolve(databaseType);
+var IntegrityConstraintViolationError = class IntegrityConstraintViolationError extends DumboError {
+	static ErrorCode = 409;
+	static ErrorType = "IntegrityConstraintViolationError";
+	constructor(message, innerError) {
+		super({
+			errorCode: IntegrityConstraintViolationError.ErrorCode,
+			errorType: IntegrityConstraintViolationError.ErrorType,
+			message: message ?? `An integrity constraint violation occurred!`,
+			innerError
+		});
+		Object.setPrototypeOf(this, IntegrityConstraintViolationError.prototype);
+	}
 };
-const getDefaultDatabase = (driverType) => {
-	return getDatabaseMetadata(driverType)?.defaultDatabaseName;
+var UniqueConstraintError = class UniqueConstraintError extends IntegrityConstraintViolationError {
+	static ErrorCode = 409;
+	static ErrorType = "UniqueConstraintError";
+	constructor(message, innerError) {
+		super(message ?? `Unique constraint violation occurred!`, innerError);
+		this.errorType = UniqueConstraintError.ErrorType;
+		Object.setPrototypeOf(this, UniqueConstraintError.prototype);
+	}
 };
-const getDefaultDatabaseAsync = async (driverType) => {
-	return (await resolveDatabaseMetadata(driverType))?.defaultDatabaseName;
+var ForeignKeyViolationError = class ForeignKeyViolationError extends IntegrityConstraintViolationError {
+	static ErrorCode = 409;
+	static ErrorType = "ForeignKeyViolationError";
+	constructor(message, innerError) {
+		super(message ?? `Foreign key constraint violation occurred!`, innerError);
+		this.errorType = ForeignKeyViolationError.ErrorType;
+		Object.setPrototypeOf(this, ForeignKeyViolationError.prototype);
+	}
 };
-
-//#endregion
-//#region src/core/schema/dumboSchema/dumboSchema.ts
-const DEFAULT_DATABASE_NAME = "__default_database__";
-const DEFAULT_DATABASE_SCHEMA_NAME = "__default_database_schema__";
-const dumboColumn = (name, type, options) => columnSchemaComponent({
-	columnName: name,
-	type,
-	...options
-});
-const dumboIndex = (name, columnNames, options) => indexSchemaComponent({
-	indexName: name,
-	columnNames,
-	isUnique: options?.unique ?? false,
-	...options
-});
-const dumboTable = (name, definition) => {
-	const { columns, indexes, primaryKey, relationships, ...options } = definition;
-	const components = [...indexes ? Object.values(indexes) : []];
-	return tableSchemaComponent({
-		tableName: name,
-		columns: columns ?? {},
-		primaryKey: primaryKey ?? [],
-		...relationships !== void 0 ? { relationships } : {},
-		components,
-		...options
-	});
+var NotNullViolationError = class NotNullViolationError extends IntegrityConstraintViolationError {
+	static ErrorCode = 409;
+	static ErrorType = "NotNullViolationError";
+	constructor(message, innerError) {
+		super(message ?? `NOT NULL constraint violation occurred!`, innerError);
+		this.errorType = NotNullViolationError.ErrorType;
+		Object.setPrototypeOf(this, NotNullViolationError.prototype);
+	}
 };
-function dumboDatabaseSchema(nameOrTables, tables, options) {
-	return databaseSchemaSchemaComponent({
-		schemaName: typeof nameOrTables === "string" ? nameOrTables : DEFAULT_DATABASE_SCHEMA_NAME,
-		tables: (typeof nameOrTables === "string" ? tables : nameOrTables) ?? {},
-		...options
-	});
-}
-dumboDatabaseSchema.from = (schemaName, tableNames) => {
-	const tables = tableNames.reduce((acc, tableName) => {
-		acc[tableName] = dumboTable(tableName, {});
-		return acc;
-	}, {});
-	return schemaName ? dumboDatabaseSchema(schemaName, tables) : dumboDatabaseSchema(tables);
+var CheckViolationError = class CheckViolationError extends IntegrityConstraintViolationError {
+	static ErrorCode = 409;
+	static ErrorType = "CheckViolationError";
+	constructor(message, innerError) {
+		super(message ?? `CHECK constraint violation occurred!`, innerError);
+		this.errorType = CheckViolationError.ErrorType;
+		Object.setPrototypeOf(this, CheckViolationError.prototype);
+	}
 };
-function dumboDatabase(nameOrSchemas, schemasOrOptions, options) {
-	const databaseName = typeof nameOrSchemas === "string" ? nameOrSchemas : DEFAULT_DATABASE_NAME;
-	const schemasOrSchema = typeof nameOrSchemas === "string" ? schemasOrOptions ?? {} : nameOrSchemas;
-	return databaseSchemaComponent({
-		databaseName,
-		schemas: "schemaComponentKey" in schemasOrSchema && isSchemaComponentOfType(schemasOrSchema, "sc:dumbo:database_schema") ? { [DEFAULT_DATABASE_SCHEMA_NAME]: schemasOrSchema } : schemasOrSchema,
-		...typeof nameOrSchemas === "string" ? options : schemasOrOptions
-	});
-}
-dumboDatabase.from = (databaseName, schemaNames) => {
-	const schemas = schemaNames.reduce((acc, schemaName) => {
-		acc[schemaName] = dumboDatabaseSchema(schemaName, {});
-		return acc;
-	}, {});
-	return databaseName ? dumboDatabase(databaseName, schemas) : dumboDatabase(schemas);
+var ExclusionViolationError = class ExclusionViolationError extends IntegrityConstraintViolationError {
+	static ErrorCode = 409;
+	static ErrorType = "ExclusionViolationError";
+	constructor(message, innerError) {
+		super(message ?? `Exclusion constraint violation occurred!`, innerError);
+		this.errorType = ExclusionViolationError.ErrorType;
+		Object.setPrototypeOf(this, ExclusionViolationError.prototype);
+	}
 };
-dumboDatabase.defaultName = DEFAULT_DATABASE_NAME;
-dumboDatabaseSchema.defaultName = DEFAULT_DATABASE_SCHEMA_NAME;
-const dumboSchema = {
-	database: dumboDatabase,
-	schema: dumboDatabaseSchema,
-	table: dumboTable,
-	column: dumboColumn,
-	index: dumboIndex
+var DataError = class DataError extends DumboError {
+	static ErrorCode = 400;
+	static ErrorType = "DataError";
+	constructor(message, innerError) {
+		super({
+			errorCode: DataError.ErrorCode,
+			errorType: DataError.ErrorType,
+			message: message ?? `A data error occurred (e.g. invalid value, type mismatch).`,
+			innerError
+		});
+		Object.setPrototypeOf(this, DataError.prototype);
+	}
 };
-
-//#endregion
-//#region src/core/locks/databaseLock.ts
-const defaultDatabaseLockOptions = { timeoutMs: 1e4 };
-const NoDatabaseLock = {
-	acquire: () => Promise.resolve(),
-	tryAcquire: () => Promise.resolve(true),
-	release: () => Promise.resolve(true),
-	withAcquire: (_execute, handle, _options) => handle()
+var InvalidOperationError = class InvalidOperationError extends DumboError {
+	static ErrorCode = 400;
+	static ErrorType = "InvalidOperationError";
+	constructor(message, innerError) {
+		super({
+			errorCode: InvalidOperationError.ErrorCode,
+			errorType: InvalidOperationError.ErrorType,
+			message: message ?? `Invalid operation (e.g. syntax error, insufficient privileges, undefined table).`,
+			innerError
+		});
+		Object.setPrototypeOf(this, InvalidOperationError.prototype);
+	}
 };
 
 //#endregion
-//#region src/core/query/selectors.ts
-const firstOrNull = async (getResult) => {
-	const result = await getResult;
-	return result.rows.length > 0 ? result.rows[0] ?? null : null;
-};
-const first = async (getResult) => {
-	const result = await getResult;
-	if (result.rows.length === 0) throw new Error("Query didn't return any result");
-	return result.rows[0];
+//#region src/core/execute/execute.ts
+const mapColumnToJSON = (column, serializer, options) => ({ [column]: (value) => {
+	if (typeof value === "string") try {
+		return serializer.deserialize(value, options);
+	} catch {}
+	return value;
+} });
+const mapColumnToBigint = (column) => ({ [column]: (value) => {
+	if (typeof value === "number" || typeof value === "string") return BigInt(value);
+	return value;
+} });
+const mapColumnToDate = (column) => ({ [column]: (value) => {
+	if (typeof value === "number" || typeof value === "string") return new Date(value);
+	return value;
+} });
+const mapSQLQueryResult = (result, mapping) => {
+	if (typeof result !== "object" || result === null) return result;
+	const mappedResult = { ...result };
+	for (const column of Object.keys(mapping)) if (column in mappedResult) mappedResult[column] = mapping[column](mappedResult[column]);
+	return mappedResult;
 };
-const singleOrNull = async (getResult) => {
-	const result = await getResult;
-	if (result.rows.length > 1) throw new Error("Query had more than one result");
-	return result.rows.length > 0 ? result.rows[0] ?? null : null;
+var BatchCommandNoChangesError = class BatchCommandNoChangesError extends DumboError {
+	static ErrorCode = 409;
+	static ErrorType = "BatchCommandNoChangesError";
+	statementIndex;
+	constructor(statementIndex) {
+		super({
+			errorCode: BatchCommandNoChangesError.ErrorCode,
+			errorType: BatchCommandNoChangesError.ErrorType,
+			message: `Batch command at index ${statementIndex} affected no rows`
+		});
+		this.name = "BatchCommandNoChangesError";
+		this.statementIndex = statementIndex;
+		Object.setPrototypeOf(this, BatchCommandNoChangesError.prototype);
+	}
 };
-const single = async (getResult) => {
-	const result = await getResult;
-	if (result.rows.length === 0) throw new Error("Query didn't return any result");
-	if (result.rows.length > 1) throw new Error("Query had more than one result");
-	return result.rows[0];
+const sqlExecutor = (sqlExecutor, options) => ({
+	query: (sql, queryOptions) => executeInNewDbClient((client) => sqlExecutor.query(client, sql, queryOptions), options),
+	batchQuery: (sqls, queryOptions) => executeInNewDbClient((client) => sqlExecutor.batchQuery(client, sqls, queryOptions), options),
+	command: (sql, commandOptions) => executeInNewDbClient((client) => sqlExecutor.command(client, sql, commandOptions), options),
+	batchCommand: (sqls, commandOptions) => executeInNewDbClient((client) => sqlExecutor.batchCommand(client, sqls, commandOptions), options)
+});
+const sqlExecutorInNewConnection = (options) => ({
+	query: (sql, queryOptions) => executeInNewConnection((connection) => connection.execute.query(sql, queryOptions), options),
+	batchQuery: (sqls, queryOptions) => executeInNewConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), options),
+	command: (sql, commandOptions) => executeInNewConnection((connection) => connection.execute.command(sql, commandOptions), options),
+	batchCommand: (sqls, commandOptions) => executeInNewConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), options)
+});
+const sqlExecutorInAmbientConnection = (options) => ({
+	query: (sql, queryOptions) => executeInAmbientConnection((connection) => connection.execute.query(sql, queryOptions), options),
+	batchQuery: (sqls, queryOptions) => executeInAmbientConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), options),
+	command: (sql, commandOptions) => executeInAmbientConnection((connection) => connection.execute.command(sql, commandOptions), options),
+	batchCommand: (sqls, commandOptions) => executeInAmbientConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), options)
+});
+const executeInNewDbClient = async (handle, options) => {
+	const { connect, close } = options;
+	const client = await connect();
+	try {
+		return await handle(client);
+	} catch (error) {
+		if (close) await close(client, error);
+		throw error;
+	}
 };
-const count = async (getResult) => {
-	const result = await single(getResult);
-	return Number(result.count);
+const executeInNewConnection = async (handle, options) => {
+	const connection = await options.connection();
+	try {
+		return await handle(connection);
+	} finally {
+		await connection.close();
+	}
 };
-const exists = async (getResult) => {
-	const result = await single(getResult);
-	return result.exists === true || result.exists === 1;
+const executeInAmbientConnection = async (handle, options) => {
+	const connection = await options.connection();
+	try {
+		return await handle(connection);
+	} finally {}
 };
 
 //#endregion
-//#region src/core/serializer/json/index.ts
-const bigIntReplacer = (_key, value) => {
-	return typeof value === "bigint" ? value.toString() : value;
-};
-const dateReplacer = (_key, value) => {
-	return value instanceof Date ? value.toISOString() : value;
-};
-const isFirstLetterNumeric = (str) => {
-	const c = str.charCodeAt(0);
-	return c >= 48 && c <= 57;
-};
-const isFirstLetterNumericOrMinus = (str) => {
-	const c = str.charCodeAt(0);
-	return c >= 48 && c <= 57 || c === 45;
-};
-const bigIntReviver = (_key, value, context) => {
-	if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) try {
-		return BigInt(context?.source ?? value.toString());
-	} catch {
-		return value;
-	}
-	if (typeof value === "string" && value.length > 15) {
-		if (isFirstLetterNumericOrMinus(value)) {
-			const num = Number(value);
-			if (Number.isFinite(num) && !Number.isSafeInteger(num)) try {
-				return BigInt(value);
-			} catch {}
-		}
-	}
-	return value;
+//#region src/core/connections/transaction.ts
+const toTransactionResult = (transactionResult) => transactionResult !== void 0 && transactionResult !== null && typeof transactionResult === "object" && "success" in transactionResult ? transactionResult : {
+	success: true,
+	result: transactionResult
 };
-const dateReviver = (_key, value) => {
-	if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
-		const date = new Date(value);
-		if (!isNaN(date.getTime())) return date;
+const executeInTransaction = async (transaction, handle) => {
+	await transaction.begin();
+	try {
+		const { success, result } = toTransactionResult(await handle(transaction));
+		if (success) await transaction.commit();
+		else await transaction.rollback();
+		return result;
+	} catch (e) {
+		await transaction.rollback();
+		throw e;
 	}
-	return value;
-};
-const composeJSONReplacers = (...replacers) => {
-	const filteredReplacers = replacers.filter((r) => r !== void 0);
-	if (filteredReplacers.length === 0) return void 0;
-	return (key, value) => filteredReplacers.reduce((accValue, replacer) => replacer(key, accValue), value);
-};
-const composeJSONRevivers = (...revivers) => {
-	const filteredRevivers = revivers.filter((r) => r !== void 0);
-	if (filteredRevivers.length === 0) return void 0;
-	return (key, value, context) => filteredRevivers.reduce((accValue, reviver) => reviver(key, accValue, context), value);
-};
-const JSONReplacer = (opts) => composeJSONReplacers(opts?.replacer, opts?.failOnBigIntSerialization !== true ? JSONReplacers.bigInt : void 0, opts?.useDefaultDateSerialization !== true ? JSONReplacers.date : void 0);
-const JSONReviver = (opts) => composeJSONRevivers(opts?.reviver, opts?.parseBigInts === true ? JSONRevivers.bigInt : void 0, opts?.parseDates === true ? JSONRevivers.date : void 0);
-const JSONReplacers = {
-	bigInt: bigIntReplacer,
-	date: dateReplacer
-};
-const JSONRevivers = {
-	bigInt: bigIntReviver,
-	date: dateReviver
 };
-const jsonSerializer = (options) => {
-	const defaultReplacer = JSONReplacer(options);
-	const defaultReviver = JSONReviver(options);
+const transactionFactoryWithDbClient = (connect, initTransaction) => {
+	let currentTransaction = void 0;
+	const getOrInitCurrentTransaction = (options) => currentTransaction ?? (currentTransaction = initTransaction(connect(), {
+		close: () => {
+			currentTransaction = void 0;
+			return Promise.resolve();
+		},
+		...options ?? {}
+	}));
 	return {
-		serialize: (object, serializerOptions) => JSON.stringify(object, serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer),
-		deserialize: (payload, deserializerOptions) => JSON.parse(payload, deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver)
+		transaction: getOrInitCurrentTransaction,
+		withTransaction: (handle, options) => executeInTransaction(getOrInitCurrentTransaction(options), handle)
 	};
 };
-const JSONSerializer = Object.assign(jsonSerializer(), { from: (options) => options?.serialization?.serializer ?? (options?.serialization?.options ? jsonSerializer(options?.serialization?.options) : JSONSerializer) });
-const JSONCodec = (options) => {
-	const serializer = "serializer" in options ? options.serializer : jsonSerializer("serializerOptions" in options ? options.serializerOptions : void 0);
-	const upcast = options.upcast ?? ((doc) => doc);
-	const downcast = options.downcast ?? ((doc) => doc);
-	return {
-		decode: (payload, decodeOptions) => {
-			return upcast(decodeOptions ? serializer.deserialize(payload, decodeOptions) : serializer.deserialize(payload));
-		},
-		encode: (object, encodeOptions) => {
-			const downcasted = downcast(object);
-			return encodeOptions ? serializer.serialize(downcasted, encodeOptions) : serializer.serialize(downcasted);
-		}
-	};
+const wrapInConnectionClosure = async (connection, handle) => {
+	try {
+		return await handle();
+	} finally {
+		await connection.close();
+	}
 };
-
-//#endregion
-//#region src/core/sql/parametrizedSQL/parametrizedSQL.ts
-const ParametrizedSQLBuilder = ({ mapParamPlaceholder }) => {
-	const sql = [];
-	const params = [];
+const transactionFactoryWithNewConnection = (connect) => ({
+	transaction: (options) => {
+		const connection = connect();
+		const transaction = connection.transaction(options);
+		return {
+			...transaction,
+			commit: () => wrapInConnectionClosure(connection, () => transaction.commit()),
+			rollback: () => wrapInConnectionClosure(connection, () => transaction.rollback())
+		};
+	},
+	withTransaction: (handle, options) => {
+		const connection = connect();
+		const withTx = connection.withTransaction;
+		return wrapInConnectionClosure(connection, () => withTx(handle, options));
+	}
+});
+const transactionFactoryWithAmbientConnection = (connect) => ({
+	transaction: (options) => {
+		const transaction = connect().transaction(options);
+		return {
+			...transaction,
+			commit: () => transaction.commit(),
+			rollback: () => transaction.rollback()
+		};
+	},
+	withTransaction: (handle, options) => {
+		const withTx = connect().withTransaction;
+		return withTx(handle, options);
+	}
+});
+const transactionFactoryWithAsyncAmbientConnection = (driverType, connect, close) => {
+	close ??= () => Promise.resolve();
 	return {
-		addSQL(str) {
-			sql.push(str);
-			return this;
-		},
-		addParam(value) {
-			sql.push(mapParamPlaceholder(params.length, value));
-			params.push(value);
-			return this;
-		},
-		addParams(values) {
-			const placeholders = values.map((value, i) => mapParamPlaceholder(params.length + i, value));
-			this.addSQL(`${placeholders.join(", ")}`);
-			params.push(...values);
-			return this;
-		},
-		build() {
+		transaction: (options) => {
+			let conn = null;
+			let innerTx = null;
+			let connectingPromise = null;
+			const ensureConnection = async () => {
+				if (conn) return innerTx;
+				if (!connectingPromise) connectingPromise = (async () => {
+					conn = await connect();
+					innerTx = conn.transaction(options);
+				})();
+				await connectingPromise;
+				return innerTx;
+			};
 			return {
-				query: sql.join(""),
-				params
+				driverType,
+				get connection() {
+					if (!conn) throw new Error("Transaction not started - call begin() first");
+					return conn;
+				},
+				execute: {
+					query: async (sql, queryOptions) => {
+						return (await ensureConnection()).execute.query(sql, queryOptions);
+					},
+					batchQuery: async (sqls, queryOptions) => {
+						return (await ensureConnection()).execute.batchQuery(sqls, queryOptions);
+					},
+					command: async (sql, commandOptions) => {
+						return (await ensureConnection()).execute.command(sql, commandOptions);
+					},
+					batchCommand: async (sqls, commandOptions) => {
+						return (await ensureConnection()).execute.batchCommand(sqls, commandOptions);
+					}
+				},
+				begin: async () => {
+					return (await ensureConnection()).begin();
+				},
+				commit: async () => {
+					if (!innerTx) throw new Error("Transaction not started");
+					try {
+						return await innerTx.commit();
+					} finally {
+						if (conn) await close(conn);
+					}
+				},
+				rollback: async (error) => {
+					if (!innerTx) {
+						if (conn) await close(conn);
+						return;
+					}
+					try {
+						return await innerTx.rollback(error);
+					} finally {
+						if (conn) await close(conn);
+					}
+				},
+				_transactionOptions: void 0
 			};
+		},
+		withTransaction: async (handle, options) => {
+			const conn = await connect();
+			try {
+				const withTx = conn.withTransaction;
+				return await withTx(handle, options);
+			} finally {
+				await close(conn);
+			}
 		}
 	};
 };
 
 //#endregion
-//#region src/core/sql/tokens/sqlToken.ts
-const SQLToken = (sqlTokenType, map) => {
-	const factory = (input) => {
-		let props;
-		if (map !== void 0) props = map(input);
-		else if (input === void 0 || input === null) props = {};
-		else if (typeof input === "object" && !Array.isArray(input)) props = input;
-		else throw new Error(`Cannot create SQLToken of type ${sqlTokenType} with input: ${input}`);
-		return {
-			sqlTokenType,
-			[sqlTokenType]: true,
-			...props
-		};
-	};
-	const check = (token) => SQLToken.check(token) && token.sqlTokenType === sqlTokenType;
-	return {
-		from: factory,
-		check,
-		type: sqlTokenType
+//#region src/core/connections/connection.ts
+const createAmbientConnection = (options) => {
+	const { driverType, client, executor, initTransaction, serializer } = options;
+	const clientPromise = Promise.resolve(client);
+	const closePromise = Promise.resolve();
+	const open = () => clientPromise;
+	const close = () => closePromise;
+	const typedConnection = {
+		driverType,
+		open,
+		close,
+		...transactionFactoryWithDbClient(open, initTransaction(() => typedConnection)),
+		execute: sqlExecutor(executor({ serializer }), { connect: open }),
+		_transactionType: void 0
 	};
+	return typedConnection;
 };
-SQLToken.check = (token) => token !== null && typeof token === "object" && "sqlTokenType" in token;
-const SQLIdentifier = SQLToken("SQL_IDENTIFIER", (value) => ({ value }));
-const SQLPlain = SQLToken("SQL_RAW", (value) => ({ value }));
-const SQLLiteral = SQLToken("SQL_LITERAL", (value) => ({ value }));
-const SQLArray = SQLToken("SQL_ARRAY", (input) => {
-	if (Array.isArray(input)) return { value: input };
-	return input.mode !== void 0 ? {
-		value: input.value,
-		mode: input.mode
-	} : { value: input.value };
-});
-const SQLIn = SQLToken("SQL_IN", ({ column, values, mode }) => mode !== void 0 ? {
-	column: SQLIdentifier.from(column),
-	values: SQLArray.from(values),
-	mode
-} : {
-	column: SQLIdentifier.from(column),
-	values: SQLArray.from(values)
-});
-
-//#endregion
-//#region src/core/sql/tokens/columnTokens.ts
-const ColumnTypeToken = (sqlTokenType, jsTypeName, map) => {
-	const factory = (input) => {
-		let props;
-		if (map !== void 0) props = map(input);
-		else if (input === void 0 || input === null) props = {};
-		else if (typeof input === "object" && !Array.isArray(input)) props = input;
-		else throw new Error(`Cannot create SQLToken of type ${sqlTokenType} with input: ${input}`);
-		return {
-			sqlTokenType,
-			[sqlTokenType]: true,
-			jsTypeName,
-			...props
-		};
+const createSingletonConnection = (options) => {
+	const { driverType, connect, close, initTransaction, executor, serializer } = options;
+	let client = null;
+	let connectPromise = null;
+	const getClient = async () => {
+		if (client) return client;
+		if (!connectPromise) connectPromise = connect().then((c) => {
+			client = c;
+			return c;
+		});
+		return connectPromise;
 	};
-	const check = (token) => SQLToken.check(token) && token.sqlTokenType === sqlTokenType;
-	return {
-		from: factory,
-		check,
-		type: sqlTokenType
+	const typedConnection = {
+		driverType,
+		open: getClient,
+		close: () => client ? close(client) : Promise.resolve(),
+		...transactionFactoryWithDbClient(getClient, initTransaction(() => typedConnection)),
+		execute: sqlExecutor(executor({ serializer }), { connect: getClient }),
+		_transactionType: void 0
 	};
+	return typedConnection;
 };
-const SerialToken = ColumnTypeToken("SQL_COLUMN_SERIAL", "value_type:js:number");
-const BigSerialToken = ColumnTypeToken("SQL_COLUMN_BIGSERIAL", "value_type:js:bigint");
-const IntegerToken = ColumnTypeToken("SQL_COLUMN_INTEGER", "value_type:js:number");
-const BigIntegerToken = ColumnTypeToken("SQL_COLUMN_BIGINT", "value_type:js:bigint");
-const JSONBToken = {
-	type: "SQL_COLUMN_JSONB",
-	from: () => {
-		return {
-			sqlTokenType: "SQL_COLUMN_JSONB",
-			["SQL_COLUMN_JSONB"]: true
-		};
-	},
-	check: (token) => SQLToken.check(token) && token.sqlTokenType === "SQL_COLUMN_JSONB"
-};
-const TimestampToken = ColumnTypeToken("SQL_COLUMN_TIMESTAMP", "value_type:js:date");
-const TimestamptzToken = ColumnTypeToken("SQL_COLUMN_TIMESTAMPTZ", "value_type:js:date");
-const VarcharToken = ColumnTypeToken("SQL_COLUMN_VARCHAR", "value_type:js:string", (length) => ({
-	length: length ?? "max",
-	jsTypeName: "value_type:js:string"
-}));
-const AutoIncrementSQLColumnToken = ColumnTypeToken("SQL_COLUMN_AUTO_INCREMENT", "value_type:js:bigint");
-const SQLColumnTypeTokens = {
-	AutoIncrement: AutoIncrementSQLColumnToken,
-	BigInteger: BigIntegerToken,
-	BigSerial: BigSerialToken,
-	Integer: IntegerToken,
-	JSONB: JSONBToken,
-	Serial: SerialToken,
-	Timestamp: TimestampToken,
-	Timestamptz: TimestamptzToken,
-	Varchar: VarcharToken
+const createTransientConnection = (options) => {
+	const { driverType, open, close, initTransaction, executor, serializer } = options;
+	const typedConnection = {
+		driverType,
+		open,
+		close,
+		...transactionFactoryWithDbClient(open, initTransaction(() => typedConnection)),
+		execute: sqlExecutor(executor({ serializer }), { connect: open }),
+		_transactionType: void 0
+	};
+	return typedConnection;
 };
-const SQLColumnTypeTokensFactory = {
-	AutoIncrement: AutoIncrementSQLColumnToken.from,
-	BigInteger: BigIntegerToken.from(),
-	BigSerial: BigSerialToken.from(),
-	Integer: IntegerToken.from(),
-	JSONB: JSONBToken.from,
-	Serial: SerialToken.from(),
-	Timestamp: TimestampToken.from(),
-	Timestamptz: TimestamptzToken.from(),
-	Varchar: VarcharToken.from
+const createConnection = (options) => {
+	const { driverType, connect, close, initTransaction, executor, serializer } = options;
+	let client = null;
+	let connectPromise = null;
+	const getClient = async () => {
+		if (client) return client;
+		if (!connectPromise) connectPromise = connect().then((c) => {
+			client = c;
+			return c;
+		});
+		return connectPromise;
+	};
+	const typedConnection = {
+		driverType,
+		open: getClient,
+		close: () => client ? close(client) : Promise.resolve(),
+		...transactionFactoryWithDbClient(getClient, initTransaction(() => typedConnection)),
+		execute: sqlExecutor(executor({ serializer }), { connect: getClient }),
+		_transactionType: void 0
+	};
+	return typedConnection;
 };
-const SQLColumnToken = SQLToken("SQL_COLUMN");
-
-//#endregion
-//#region src/core/sql/processors/sqlProcessor.ts
-const SQLProcessor = (options) => options;
 
 //#endregion
-//#region src/core/sql/processors/defaultProcessors.ts
-const ExpandArrayProcessor = SQLProcessor({
-	canHandle: "SQL_ARRAY",
-	handle: (token, { builder, serializer, mapper }) => {
-		if (token.value.length === 0) throw new Error("Empty arrays are not supported. If you're using it with SELECT IN statement Use SQL.in(column, array) helper instead.");
-		builder.addParams(mapper.mapValue(token.value, serializer));
-	}
-});
-const ExpandSQLInProcessor = SQLProcessor({
-	canHandle: "SQL_IN",
-	handle: (token, context) => {
-		const { builder, mapper, processorsRegistry, serializer } = context;
-		const { values: inValues, column } = token;
-		if (inValues.value.length === 0) {
-			builder.addParam(mapper.mapValue(false, serializer));
-			return;
-		}
-		builder.addSQL(mapper.mapValue(column.value, serializer));
-		builder.addSQL(` IN (`);
-		const arrayProcessor = processorsRegistry.get(SQLArray.type);
-		if (!arrayProcessor) throw new Error("No sql processor registered for an array. Cannot expand IN statement");
-		arrayProcessor.handle(inValues, {
-			builder,
-			mapper,
-			processorsRegistry,
-			serializer
-		});
-		builder.addSQL(`)`);
+//#region src/core/taskProcessing/taskProcessor.ts
+var TaskProcessor = class {
+	queue = [];
+	isProcessing = false;
+	activeTasks = 0;
+	activeGroups = /* @__PURE__ */ new Set();
+	options;
+	stopped = false;
+	constructor(options) {
+		this.options = options;
 	}
-});
-const FormatIdentifierProcessor = SQLProcessor({
-	canHandle: "SQL_IDENTIFIER",
-	handle: (token, { builder, mapper, serializer }) => {
-		builder.addSQL(mapper.mapValue(token, serializer));
+	enqueue(task, options) {
+		if (this.stopped) return Promise.reject(new DumboError("TaskProcessor has been stopped"));
+		if (this.queue.length >= this.options.maxQueueSize) return Promise.reject(new TransientDatabaseError("Too many pending connections. Please try again later."));
+		return this.schedule(task, options);
 	}
-});
-const MapLiteralProcessor = SQLProcessor({
-	canHandle: "SQL_LITERAL",
-	handle: (token, { builder, mapper, serializer }) => builder.addParam(mapper.mapValue(token.value, serializer))
-});
-
-//#endregion
-//#region src/core/sql/processors/sqlProcessorRegistry.ts
-const SQLProcessorsRegistry = (options) => {
-	const processors = options ? new Map(options.from.all()) : /* @__PURE__ */ new Map();
-	function register(...args) {
-		if (args.length === 1 && typeof args[0] === "object" && !Array.isArray(args[0])) Object.entries(args[0]).forEach(([_, processor]) => {
-			processors.set(processor.canHandle, processor);
-		});
-		else args.forEach((p) => processors.set(p.canHandle, p));
-		return registry;
+	waitForEndOfProcessing() {
+		return this.schedule(({ ack }) => Promise.resolve(ack()));
 	}
-	const registry = {
-		register,
-		get: (tokenType) => {
-			return processors.get(tokenType) ?? null;
-		},
-		all: () => processors
-	};
-	return registry;
-};
-
-//#endregion
-//#region src/core/sql/processors/columnProcessors.ts
-const mapDefaultSQLColumnProcessors = (mapColumnType) => ({
-	AutoIncrement: SQLProcessor({
-		canHandle: "SQL_COLUMN_AUTO_INCREMENT",
-		handle: (token, context) => {
-			mapColumnType(token, context);
-		}
-	}),
-	BigInteger: SQLProcessor({
-		canHandle: "SQL_COLUMN_BIGINT",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	BigSerial: SQLProcessor({
-		canHandle: "SQL_COLUMN_BIGSERIAL",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	Serial: SQLProcessor({
-		canHandle: "SQL_COLUMN_SERIAL",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	Integer: SQLProcessor({
-		canHandle: "SQL_COLUMN_INTEGER",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	JSONB: SQLProcessor({
-		canHandle: "SQL_COLUMN_JSONB",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	Timestamp: SQLProcessor({
-		canHandle: "SQL_COLUMN_TIMESTAMP",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	Timestamptz: SQLProcessor({
-		canHandle: "SQL_COLUMN_TIMESTAMPTZ",
-		handle: (token, context) => mapColumnType(token, context)
-	}),
-	Varchar: SQLProcessor({
-		canHandle: "SQL_COLUMN_VARCHAR",
-		handle: (token, context) => mapColumnType(token, context)
-	})
-});
-
-//#endregion
-//#region src/core/sql/processors/index.ts
-const defaultProcessorsRegistry = globalThis.defaultProcessorsRegistry = globalThis.defaultProcessorsRegistry ?? SQLProcessorsRegistry().register(FormatIdentifierProcessor, MapLiteralProcessor, ExpandArrayProcessor, ExpandSQLInProcessor);
-
-//#endregion
-//#region src/core/sql/tokenizedSQL/tokenizedSQL.ts
-const TokenizedSQLBuilder = () => {
-	const sqlChunks = [];
-	const sqlTokens = [];
-	return {
-		addSQL(str) {
-			sqlChunks.push(str);
-		},
-		addSQLs(str) {
-			sqlChunks.push(...str);
-		},
-		addToken(value) {
-			sqlTokens.push(value);
-		},
-		addTokens(vals) {
-			sqlTokens.push(...vals);
-		},
-		build() {
-			return sqlChunks.length > 0 ? {
-				__brand: "tokenized-sql",
-				sqlChunks,
-				sqlTokens
-			} : TokenizedSQL.empty;
+	async stop(options) {
+		if (this.stopped) return;
+		this.stopped = true;
+		this.queue.length = 0;
+		this.activeGroups.clear();
+		if (!options?.force) await this.waitForEndOfProcessing();
+	}
+	schedule(task, options) {
+		return promiseWithDeadline((resolve, reject) => {
+			const taskWithContext = () => {
+				return new Promise((resolveTask, failTask) => {
+					task({ ack: resolveTask }).then(resolve).catch((err) => {
+						failTask(err);
+						reject(err);
+					});
+				});
+			};
+			this.queue.push({
+				task: taskWithContext,
+				options
+			});
+			if (!this.isProcessing) this.ensureProcessing();
+		}, { deadline: this.options.maxTaskIdleTime });
+	}
+	ensureProcessing() {
+		if (this.isProcessing) return;
+		this.isProcessing = true;
+		this.processQueue();
+	}
+	processQueue() {
+		try {
+			while (this.activeTasks < this.options.maxActiveTasks && this.queue.length > 0) {
+				const item = this.takeFirstAvailableItem();
+				if (item === null) return;
+				const groupId = item.options?.taskGroupId;
+				if (groupId) this.activeGroups.add(groupId);
+				this.activeTasks++;
+				this.executeItem(item);
+			}
+		} catch (error) {
+			console.error(error);
+			throw error;
+		} finally {
+			this.isProcessing = false;
+			if (this.hasItemsToProcess() && this.activeTasks < this.options.maxActiveTasks) this.ensureProcessing();
 		}
-	};
-};
-const TokenizedSQL = (strings, values) => {
-	const builder = TokenizedSQLBuilder();
-	for (let i = 0; i < strings.length; i++) {
-		if (strings[i] !== "") builder.addSQL(strings[i]);
-		if (i >= values.length) break;
-		const value = values[i];
-		if (isTokenizedSQL(value)) {
-			builder.addSQLs(value.sqlChunks);
-			builder.addTokens(value.sqlTokens);
-		} else if (SQLPlain.check(value)) builder.addSQL(value.value);
-		else {
-			builder.addSQL(TokenizedSQL.paramPlaceholder);
-			builder.addToken(SQLToken.check(value) ? value : Array.isArray(value) ? SQLArray.from(value) : SQLLiteral.from(value));
+	}
+	async executeItem({ task, options }) {
+		try {
+			await task();
+		} finally {
+			this.activeTasks--;
+			if (options && options.taskGroupId) this.activeGroups.delete(options.taskGroupId);
+			this.ensureProcessing();
 		}
 	}
-	return builder.build();
-};
-const isTokenizedSQL = (value) => {
-	return value !== null && typeof value === "object" && "__brand" in value && value.__brand === "tokenized-sql";
+	takeFirstAvailableItem = () => {
+		const taskIndex = this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId));
+		if (taskIndex === -1) return null;
+		const [item] = this.queue.splice(taskIndex, 1);
+		return item ?? null;
+	};
+	hasItemsToProcess = () => this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId)) !== -1;
 };
-TokenizedSQL.paramPlaceholder = `__P__`;
-TokenizedSQL.empty = {
-	__brand: "tokenized-sql",
-	sqlChunks: [""],
-	sqlTokens: []
+const DEFAULT_PROMISE_DEADLINE = 2147483647;
+const promiseWithDeadline = (executor, options) => {
+	return new Promise((resolve, reject) => {
+		let taskStarted = false;
+		let timeoutId = null;
+		const deadline = options.deadline ?? DEFAULT_PROMISE_DEADLINE;
+		timeoutId = setTimeout(() => {
+			if (!taskStarted) reject(/* @__PURE__ */ new Error("Task was not started within the maximum waiting time"));
+		}, deadline);
+		timeoutId.unref();
+		executor((value) => {
+			taskStarted = true;
+			if (timeoutId) clearTimeout(timeoutId);
+			timeoutId = null;
+			resolve(value);
+		}, (reason) => {
+			if (timeoutId) clearTimeout(timeoutId);
+			timeoutId = null;
+			reject(reason);
+		});
+	});
 };
 
 //#endregion
-//#region src/core/sql/sql.ts
-function SQL(strings, ...values) {
-	return TokenizedSQL(strings, values);
-}
-function RawSQL(strings, ...values) {
-	let result = "";
-	for (let i = 0; i < strings.length; i++) {
-		result += strings[i];
-		if (i < values.length) result += String(values[i]);
-	}
-	return {
-		__brand: "tokenized-sql",
-		sqlChunks: [result],
-		sqlTokens: []
+//#region src/core/taskProcessing/executionGuards.ts
+const guardBoundedAccess = (getResource, options) => {
+	let isStopped = false;
+	const taskProcessor = new TaskProcessor({
+		maxActiveTasks: options.maxResources,
+		maxQueueSize: options.maxQueueSize ?? 1e3
+	});
+	const resourcePool = [];
+	const allResources = /* @__PURE__ */ new Set();
+	const ackCallbacks = /* @__PURE__ */ new Map();
+	const acquire = async () => taskProcessor.enqueue(async ({ ack }) => {
+		try {
+			let resource;
+			if (options.reuseResources) resource = resourcePool.pop();
+			if (!resource) {
+				resource = await getResource();
+				allResources.add(resource);
+			}
+			ackCallbacks.set(resource, ack);
+			return resource;
+		} catch (e) {
+			ack();
+			throw e;
+		}
+	});
+	const release = (resource) => {
+		const ack = ackCallbacks.get(resource);
+		if (ack) {
+			ackCallbacks.delete(resource);
+			if (options.reuseResources) resourcePool.push(resource);
+			ack();
+		}
+	};
+	const execute = async (operation) => {
+		const resource = await acquire();
+		try {
+			return await operation(resource);
+		} finally {
+			release(resource);
+		}
+	};
+	return {
+		acquire,
+		release,
+		execute,
+		waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
+		stop: async (stopOptions) => {
+			if (isStopped) return;
+			isStopped = true;
+			if (options?.closeResource) {
+				const resources = [...allResources];
+				allResources.clear();
+				resourcePool.length = 0;
+				await Promise.all(resources.map(async (resource) => await options.closeResource(resource)));
+			}
+			await taskProcessor.stop(stopOptions);
+		}
 	};
-}
-const isSQL = (value) => {
-	if (value === void 0 || value === null) return false;
-	return isTokenizedSQL(value);
 };
-const emptySQL = {
-	__brand: "tokenized-sql",
-	sqlChunks: [""],
-	sqlTokens: []
+const guardInitializedOnce = (initialize, options) => {
+	let initPromise = null;
+	const taskProcessor = new TaskProcessor({
+		maxActiveTasks: 1,
+		maxQueueSize: options?.maxQueueSize ?? 1e3
+	});
+	const ensureInitialized = async (retryCount = 0) => {
+		if (initPromise !== null) return initPromise;
+		return taskProcessor.enqueue(async ({ ack }) => {
+			if (initPromise !== null) {
+				ack();
+				return initPromise;
+			}
+			try {
+				const promise = initialize();
+				initPromise = promise;
+				const result = await promise;
+				ack();
+				return result;
+			} catch (error) {
+				initPromise = null;
+				ack();
+				if (retryCount < (options?.maxRetries ?? 3)) return ensureInitialized(retryCount + 1);
+				throw error;
+			}
+		}, { taskGroupId: v7() });
+	};
+	return {
+		ensureInitialized,
+		reset: () => {
+			initPromise = null;
+		},
+		stop: (options) => taskProcessor.stop(options)
+	};
 };
-const mergeSQL = (sqls, separator = " ") => {
-	const parametrized = sqls.filter((sql) => !isEmpty(sql)).map((sql) => sql);
-	const params = parametrized.flatMap((p) => p.sqlTokens);
-	const sqlChunks = parametrized.flatMap((p, i) => i == parametrized.length - 1 || separator === "" ? p.sqlChunks : [...p.sqlChunks, separator]);
-	return sqlChunks.length > 0 ? {
-		__brand: "tokenized-sql",
-		sqlChunks,
-		sqlTokens: params
-	} : TokenizedSQL.empty;
+
+//#endregion
+//#region src/core/connections/pool.ts
+const wrapPooledConnection = (conn, onClose) => ({
+	...conn,
+	close: onClose
+});
+const createAmbientConnectionPool = (options) => {
+	const { driverType, connection } = options;
+	return createConnectionPool({
+		driverType,
+		getConnection: () => connection,
+		execute: connection.execute,
+		transaction: (options) => connection.transaction(options),
+		withConnection: (handle, _options) => handle(connection),
+		withTransaction: (handle, options) => {
+			const withTx = connection.withTransaction;
+			return withTx(handle, options);
+		}
+	});
 };
-const concatSQL = (...sqls) => mergeSQL(sqls, "");
-const isEmpty = (sql) => {
-	if (isTokenizedSQL(sql)) {
-		const parametrized = sql;
-		return parametrized.sqlChunks.every((chunk) => chunk.trim() === "") && parametrized.sqlTokens.length === 0;
-	}
-	return false;
+const createSingletonConnectionPool = (options) => {
+	const { driverType, getConnection } = options;
+	let connectionPromise = null;
+	const getExistingOrNewConnection = () => {
+		if (!connectionPromise) connectionPromise ??= Promise.resolve(getConnection());
+		return connectionPromise;
+	};
+	return {
+		driverType,
+		connection: () => getExistingOrNewConnection().then((conn) => wrapPooledConnection(conn, () => Promise.resolve())),
+		execute: sqlExecutorInAmbientConnection({
+			driverType,
+			connection: getExistingOrNewConnection
+		}),
+		withConnection: (handle, _options) => executeInAmbientConnection(handle, { connection: getExistingOrNewConnection }),
+		...transactionFactoryWithAsyncAmbientConnection(options.driverType, getExistingOrNewConnection, options.closeConnection),
+		close: async () => {
+			if (!connectionPromise) return;
+			await (await connectionPromise).close();
+		}
+	};
 };
-SQL.EMPTY = emptySQL;
-SQL.concat = concatSQL;
-SQL.merge = mergeSQL;
-SQL.format = (sql, formatter, options) => formatSQL(sql, formatter, options?.serializer ?? JSONSerializer, options);
-SQL.describe = (sql, formatter, options) => describeSQL(sql, formatter, options?.serializer ?? JSONSerializer, options);
-SQL.in = (column, values, options) => options?.mode ? SQLIn.from({
-	column,
-	values,
-	mode: options.mode
-}) : SQLIn.from({
-	column,
-	values
-});
-SQL.array = (values, options) => SQLArray.from(options?.mode ? {
-	value: values,
-	mode: options.mode
-} : values);
-SQL.identifier = SQLIdentifier.from;
-SQL.plain = SQLPlain.from;
-SQL.check = {
-	isSQL,
-	isTokenizedSQL: (value) => isTokenizedSQL(value),
-	isEmpty,
-	isIdentifier: SQLIdentifier.check,
-	isPlain: SQLPlain.check,
-	isSQLIn: SQLIn.check
+const createBoundedConnectionPool = (options) => {
+	const { driverType, maxConnections } = options;
+	const guardMaxConnections = guardBoundedAccess(options.getConnection, {
+		maxResources: maxConnections,
+		reuseResources: true
+	});
+	let closed = false;
+	const executeWithPooling = async (operation) => {
+		const conn = await guardMaxConnections.acquire();
+		try {
+			return await operation(conn);
+		} finally {
+			guardMaxConnections.release(conn);
+		}
+	};
+	return {
+		driverType,
+		connection: async () => {
+			const conn = await guardMaxConnections.acquire();
+			return wrapPooledConnection(conn, () => Promise.resolve(guardMaxConnections.release(conn)));
+		},
+		execute: {
+			query: (sql, opts) => executeWithPooling((c) => c.execute.query(sql, opts)),
+			batchQuery: (sqls, opts) => executeWithPooling((c) => c.execute.batchQuery(sqls, opts)),
+			command: (sql, opts) => executeWithPooling((c) => c.execute.command(sql, opts)),
+			batchCommand: (sqls, opts) => executeWithPooling((c) => c.execute.batchCommand(sqls, opts))
+		},
+		withConnection: executeWithPooling,
+		...transactionFactoryWithAsyncAmbientConnection(driverType, guardMaxConnections.acquire, guardMaxConnections.release),
+		close: async () => {
+			if (closed) return;
+			closed = true;
+			await guardMaxConnections.stop({ force: true });
+		}
+	};
+};
+const createSingletonClientConnectionPool = (options) => {
+	const { driverType, dbClient } = options;
+	return createSingletonConnectionPool({
+		getConnection: () => options.connectionFactory({ dbClient }),
+		driverType
+	});
+};
+const createAlwaysNewConnectionPool = (options) => {
+	const { driverType, getConnection, connectionOptions } = options;
+	return createConnectionPool({
+		driverType,
+		getConnection: () => connectionOptions ? getConnection(connectionOptions) : getConnection()
+	});
+};
+const createConnectionPool = (pool) => {
+	const { driverType, getConnection } = pool;
+	const connection = "connection" in pool ? pool.connection : () => Promise.resolve(getConnection());
+	return {
+		driverType,
+		connection,
+		withConnection: "withConnection" in pool ? pool.withConnection : (handle, _options) => executeInNewConnection(handle, { connection }),
+		close: "close" in pool ? pool.close : () => Promise.resolve(),
+		execute: "execute" in pool ? pool.execute : sqlExecutorInNewConnection({
+			driverType,
+			connection
+		}),
+		..."transaction" in pool && "withTransaction" in pool ? {
+			transaction: pool.transaction,
+			withTransaction: pool.withTransaction
+		} : transactionFactoryWithNewConnection(getConnection)
+	};
 };
-const columnFactory = SQLColumnToken.from;
-columnFactory.type = SQLColumnTypeTokensFactory;
-SQL.column = columnFactory;
 
 //#endregion
-//#region src/core/sql/valueMappers/reservedSqlWords.ts
-const ansiSqlReservedMap = {
-	ALL: true,
-	AND: true,
-	ANY: true,
-	ARRAY: true,
-	AS: true,
-	ASC: true,
-	AUTHORIZATION: true,
-	BETWEEN: true,
-	BINARY: true,
-	BOTH: true,
-	CASE: true,
-	CAST: true,
-	CHECK: true,
-	COLLATE: true,
-	COLUMN: true,
-	CONSTRAINT: true,
-	CREATE: true,
-	CROSS: true,
-	CURRENT_DATE: true,
-	CURRENT_TIME: true,
-	CURRENT_TIMESTAMP: true,
-	CURRENT_USER: true,
-	DEFAULT: true,
-	DEFERRABLE: true,
-	DESC: true,
-	DISTINCT: true,
-	DO: true,
-	ELSE: true,
-	END: true,
-	EXCEPT: true,
-	FALSE: true,
-	FOR: true,
-	FOREIGN: true,
-	FROM: true,
-	FULL: true,
-	GRANT: true,
-	GROUP: true,
-	HAVING: true,
-	IN: true,
-	INITIALLY: true,
-	INNER: true,
-	INTERSECT: true,
-	INTO: true,
-	IS: true,
-	JOIN: true,
-	LEADING: true,
-	LEFT: true,
-	LIKE: true,
-	LOCALTIME: true,
-	LOCALTIMESTAMP: true,
-	NATURAL: true,
-	NEW: true,
-	NOT: true,
-	NULL: true,
-	NULLS: true,
-	OLD: true,
-	ON: true,
-	ONLY: true,
-	OPEN: true,
-	OR: true,
-	ORDER: true,
-	OUTER: true,
-	OVERLAPS: true,
-	PARTITION: true,
-	PLACING: true,
-	PRIMARY: true,
-	REFERENCES: true,
-	RIGHT: true,
-	SELECT: true,
-	SESSION_USER: true,
-	SIMILAR: true,
-	SOME: true,
-	TABLE: true,
-	THEN: true,
-	TO: true,
-	TRAILING: true,
-	TRUE: true,
-	UNION: true,
-	UNIQUE: true,
-	USER: true,
-	USING: true,
-	WHEN: true,
-	WHERE: true,
-	WITH: true,
-	WITHOUT: true,
-	ADD: true,
-	ALTER: true,
-	ARE: true,
-	AT: true,
-	BEGIN: true,
-	BY: true,
-	CASCADE: true,
-	CLOSE: true,
-	COMMIT: true,
-	CONNECT: true,
-	CONTINUE: true,
-	CORRESPONDING: true,
-	CURSOR: true,
-	DEALLOCATE: true,
-	DECLARE: true,
-	DELETE: true,
-	DESCRIBE: true,
-	DISCONNECT: true,
-	DROP: true,
-	ESCAPE: true,
-	EXECUTE: true,
-	EXISTS: true,
-	FETCH: true,
-	FIRST: true,
-	FLOAT: true,
-	GET: true,
-	GLOBAL: true,
-	GO: true,
-	GOTO: true,
-	HOUR: true,
-	IMMEDIATE: true,
-	INDICATOR: true,
-	INPUT: true,
-	INSERT: true,
-	INT: true,
-	INTEGER: true,
-	INTERVAL: true,
-	LANGUAGE: true,
-	LAST: true,
-	LOCAL: true,
-	MATCH: true,
-	MINUTE: true,
-	MODULE: true,
-	MONTH: true,
-	NATIONAL: true,
-	NEXT: true,
-	NO: true,
-	OF: true,
-	OUTPUT: true,
-	PARTIAL: true,
-	PREPARE: true,
-	PRESERVE: true,
-	PRIOR: true,
-	PRIVILEGES: true,
-	PROCEDURE: true,
-	PUBLIC: true,
-	READ: true,
-	REAL: true,
-	RESTRICT: true,
-	REVOKE: true,
-	ROLLBACK: true,
-	ROWS: true,
-	SCHEMA: true,
-	SCROLL: true,
-	SECOND: true,
-	SECTION: true,
-	SET: true,
-	SIZE: true,
-	SMALLINT: true,
-	SQL: true,
-	SQLCODE: true,
-	SQLERROR: true,
-	SQLSTATE: true,
-	TEMPORARY: true,
-	TIMEZONE_HOUR: true,
-	TIMEZONE_MINUTE: true,
-	TRANSACTION: true,
-	TRANSLATE: true,
-	TRANSLATION: true,
-	UNKNOWN: true,
-	UPDATE: true,
-	VALUE: true,
-	VALUES: true,
-	VARCHAR: true,
-	VARYING: true,
-	VIEW: true,
-	WHENEVER: true,
-	WORK: true,
-	WRITE: true,
-	YEAR: true,
-	ZONE: true
-};
-
-//#endregion
-//#region src/core/sql/valueMappers/sqlValueMapper.ts
-const ANSISQLParamPlaceholder = "?";
-const ANSISQLIdentifierQuote = "\"";
-const mapANSISQLParamPlaceholder = () => "?";
-const isReserved = (value, reserved) => !!reserved[value.toUpperCase()];
-const mapSQLIdentifier = (value, options) => {
-	if (value === void 0 || value === null) throw new Error("SQL identifier cannot be null or undefined");
-	const ident = value.toString().slice(0);
-	const quoteSign = options?.quote ?? "\"";
-	if (/^[a-z_][a-z0-9_$]*$/.test(ident) && !isReserved(ident, options?.reservedWords ?? ansiSqlReservedMap)) return ident;
-	let quoted = quoteSign;
-	for (let i = 0; i < ident.length; i++) {
-		const c = ident[i];
-		quoted += c === quoteSign ? c + c : c;
-	}
-	quoted += quoteSign;
-	return quoted;
-};
-const DefaultMapSQLParamValueOptions = {
-	mapPlaceholder: mapANSISQLParamPlaceholder,
-	mapIdentifier: mapSQLIdentifier
+//#region src/core/drivers/databaseDriver.ts
+const canHandleDriverWithConnectionString = (driver, tryParseConnectionString) => (options) => {
+	if ("driverType" in options) return options.driverType === driver;
+	if ("connectionString" in options && typeof options.connectionString === "string") return tryParseConnectionString(options.connectionString) !== null;
+	return false;
 };
-const SQLValueMapper = (options) => {
-	const mapSQLParamValueOptions = {
-		...DefaultMapSQLParamValueOptions,
-		...options ?? {}
+const DumboDatabaseDriverRegistry = () => {
+	const drivers = /* @__PURE__ */ new Map();
+	const register = (driverType, plugin) => {
+		const entry = drivers.get(driverType);
+		if (entry && (typeof entry !== "function" || typeof plugin === "function")) return;
+		drivers.set(driverType, plugin);
+	};
+	const getDriver = (options) => options.driverType ? drivers.get(options.driverType) : [...drivers.values()].find((d) => typeof d !== "function" && d.canHandle(options));
+	const tryResolve = async (options) => {
+		const driver = getDriver(options);
+		if (!driver) return null;
+		if (typeof driver !== "function") return driver;
+		const plugin = await driver();
+		register(plugin.driverType, plugin);
+		return plugin;
+	};
+	const tryGet = (options) => {
+		const driver = getDriver(options);
+		return driver && typeof driver !== "function" ? driver : null;
 	};
+	const has = (driverType) => drivers.has(driverType);
 	return {
-		mapValue: (value, serializer, mapOptions) => mapSQLParamValue(value, serializer, {
-			...mapSQLParamValueOptions,
-			...mapOptions
-		}),
-		mapPlaceholder: mapSQLParamValueOptions.mapPlaceholder,
-		mapIdentifier: mapSQLParamValueOptions.mapIdentifier
+		register,
+		tryResolve,
+		tryGet,
+		has,
+		get databaseDriverTypes() {
+			return Array.from(drivers.keys());
+		}
 	};
 };
-function mapSQLParamValue(value, serializer, options) {
-	if (value === null || value === void 0) return null;
-	else if (typeof value === "number") return value;
-	else if (typeof value === "string") return value;
-	else if (Array.isArray(value)) {
-		const mapValue = options?.mapValue ?? mapSQLParamValue;
-		return options?.mapArray ? options.mapArray(value, mapValue) : value.map((item) => mapValue(item, serializer, options));
-	} else if (typeof value === "boolean") return options?.mapBoolean ? options.mapBoolean(value) : value;
-	else if (typeof value === "bigint") return options?.mapBigInt ? options.mapBigInt(value) : value.toString();
-	else if (value instanceof Date) return options?.mapDate ? options.mapDate(value) : value.toISOString();
-	else if (SQL.check.isIdentifier(value)) return (options?.mapIdentifier ?? mapSQLIdentifier)(value.value);
-	else if (typeof value === "object") return options?.mapObject ? options.mapObject(value) : `${serializer.serialize(value).replace(/'/g, "''")}`;
-	else return serializer.serialize(value);
-}
+const dumboDatabaseDriverRegistry = globalThis.dumboDatabaseDriverRegistry = globalThis.dumboDatabaseDriverRegistry ?? DumboDatabaseDriverRegistry();
 
 //#endregion
-//#region src/core/sql/formatters/sqlFormatter.ts
-const SQLFormatter = ({ format, describe, valueMapper: valueMapperOptions, processorsRegistry }) => {
-	const valueMapper = SQLValueMapper(valueMapperOptions);
-	const options = {
-		builder: ParametrizedSQLBuilder({ mapParamPlaceholder: valueMapper.mapPlaceholder }),
-		mapper: valueMapper,
-		processorsRegistry: processorsRegistry ?? defaultProcessorsRegistry
+//#region src/core/drivers/index.ts
+/**
+* Accepts a `databaseType` (e.g. PostgreSQL, SQLite) and a `driverName`
+* (the library name, e.g. pg, sqlite3) and combines them to a singular
+* `databaseDriverType` which can be used in database handling.
+*/
+function toDatabaseDriverType(databaseType, driverName) {
+	return `${databaseType}:${driverName}`;
+}
+/**
+* Accepts a fully formatted `driverType` and returns the broken down
+* `databaseType` and `driverName`.
+*/
+function fromDatabaseDriverType(databaseDriverType) {
+	const parts = databaseDriverType.split(":");
+	return {
+		databaseType: parts[0],
+		driverName: parts[1]
 	};
-	const resultFormatter = {
-		format: format ?? ((sql, methodOptions) => formatSQL(sql, resultFormatter, methodOptions?.serializer ?? JSONSerializer, {
-			...options,
-			...methodOptions ?? {}
-		})),
-		describe: describe ?? ((sql, methodOptions) => describeSQL(sql, resultFormatter, methodOptions?.serializer ?? JSONSerializer, {
-			...options,
-			...methodOptions ?? {}
-		})),
-		valueMapper
-	};
-	return resultFormatter;
-};
-const dumboSQLFormatters = globalThis.dumboSQLFormatters = globalThis.dumboSQLFormatters ?? {};
-const registerFormatter = (dialect, formatter) => {
-	dumboSQLFormatters[dialect] = formatter;
-};
-const getFormatter = (dialect) => {
-	const formatterKey = dialect;
-	if (!dumboSQLFormatters[formatterKey]) throw new Error(`No SQL formatter registered for dialect: ${dialect}`);
-	return dumboSQLFormatters[formatterKey];
-};
-function formatSQL(sql, formatter, serializer, context) {
-	const mapper = context?.mapper == void 0 ? formatter.valueMapper : {
-		...formatter.valueMapper,
-		...context.mapper
-	};
-	const processorsRegistry = context?.processorsRegistry ?? defaultProcessorsRegistry;
-	const merged = Array.isArray(sql) ? SQL.merge(sql, "\n") : sql;
-	if (!isTokenizedSQL(merged)) throw new Error("Expected TokenizedSQL, got string-based SQL");
-	const builder = ParametrizedSQLBuilder({ mapParamPlaceholder: mapper.mapPlaceholder });
-	let paramIndex = 0;
-	for (let i = 0; i < merged.sqlChunks.length; i++) {
-		const sqlChunk = merged.sqlChunks[i];
-		if (sqlChunk !== TokenizedSQL.paramPlaceholder) {
-			builder.addSQL(sqlChunk);
-			continue;
-		}
-		const token = merged.sqlTokens[paramIndex++];
-		const processor = processorsRegistry.get(token.sqlTokenType);
-		if (!processor) throw new Error(`No SQL processor registered for token type: ${token.sqlTokenType}`);
-		processor.handle(token, {
-			builder,
-			processorsRegistry,
-			serializer,
-			mapper
-		});
-	}
-	return builder.build();
 }
-const describeSQL = (sql, formatter, serializer, options) => formatSQL(sql, formatter, serializer, {
-	...options ?? {},
-	mapper: { mapPlaceholder: (_, value) => serializer.serialize(value) }
-}).query;
-
-//#endregion
-//#region src/core/tracing/printing/color.ts
-let enableColors = true;
-const color = {
-	set level(value) {
-		enableColors = value === 1;
-	},
-	hex: (value) => (text) => enableColors ? ansis.hex(value)(text) : text,
-	red: (value) => enableColors ? ansis.red(value) : value,
-	green: (value) => enableColors ? ansis.green(value) : value,
-	blue: (value) => enableColors ? ansis.blue(value) : value,
-	cyan: (value) => enableColors ? ansis.cyan(value) : value,
-	yellow: (value) => enableColors ? ansis.yellow(value) : value
-};
+/**
+* Accepts a fully formatted `databaseDriverType` and returns the `driverName`.
+*/
+function getDatabaseDriverName(databaseDriverType) {
+	const { driverName } = fromDatabaseDriverType(databaseDriverType);
+	return driverName;
+}
+/**
+* Accepts a fully formatted `databaseDriverType` and returns the `databaseType`.
+*/
+function getDatabaseType(databaseDriverType) {
+	const { databaseType } = fromDatabaseDriverType(databaseDriverType);
+	return databaseType;
+}
 
 //#endregion
-//#region src/core/tracing/printing/pretty.ts
-const TWO_SPACES = "  ";
-const COLOR_STRING = color.hex("#98c379");
-const COLOR_KEY = color.hex("#61afef");
-const COLOR_NUMBER_OR_DATE = color.hex("#d19a66");
-const COLOR_BOOLEAN = color.hex("#c678dd");
-const COLOR_NULL_OR_UNDEFINED = color.hex("#c678dd");
-const COLOR_BRACKETS = color.hex("#abb2bf");
-const processString = (str, indent, handleMultiline) => {
-	if (handleMultiline && str.includes("\n")) {
-		const indentedLines = str.split("\n").map((line) => indent + TWO_SPACES + COLOR_STRING(line));
-		return COLOR_STRING("\"") + "\n" + indentedLines.join("\n") + "\n" + indent + COLOR_STRING("\"");
-	}
-	return COLOR_STRING(`"${str}"`);
-};
-const shouldPrint = (obj) => typeof obj !== "function" && typeof obj !== "symbol";
-const formatJson = (obj, indentLevel = 0, handleMultiline = false) => {
-	const indent = TWO_SPACES.repeat(indentLevel);
-	if (obj === null) return COLOR_NULL_OR_UNDEFINED("null");
-	if (obj === void 0) return COLOR_NULL_OR_UNDEFINED("undefined");
-	if (typeof obj === "string") return processString(obj, indent, handleMultiline);
-	if (typeof obj === "number" || typeof obj === "bigint" || obj instanceof Date) return COLOR_NUMBER_OR_DATE(String(obj));
-	if (typeof obj === "boolean") return COLOR_BOOLEAN(String(obj));
-	if (obj instanceof Error) {
-		const errorObj = {};
-		Object.getOwnPropertyNames(obj).forEach((key) => {
-			errorObj[key] = obj[key];
-		});
-		return formatJson(errorObj, indentLevel, handleMultiline);
-	}
-	if (obj instanceof Promise) return COLOR_STRING("Promise {pending}");
-	if (Array.isArray(obj)) {
-		const arrayItems = obj.map((item) => formatJson(item, indentLevel + 1, handleMultiline));
-		return `${COLOR_BRACKETS("[")}\n${indent}  ${arrayItems.join(`,\n${indent}  `)}\n${indent}${COLOR_BRACKETS("]")}`;
-	}
-	const entries = Object.entries(obj).filter(([_, value]) => shouldPrint(value)).map(([key, value]) => `${COLOR_KEY(`"${key}"`)}: ${formatJson(value, indentLevel + 1, handleMultiline)}`);
-	return `${COLOR_BRACKETS("{")}\n${indent}  ${entries.join(`,\n${indent}  `)}\n${indent}${COLOR_BRACKETS("}")}`;
+//#region src/core/locks/databaseLock.ts
+const defaultDatabaseLockOptions = { timeoutMs: 1e4 };
+const NoDatabaseLock = {
+	acquire: () => Promise.resolve(),
+	tryAcquire: () => Promise.resolve(true),
+	release: () => Promise.resolve(true),
+	withAcquire: (_execute, handle, _options) => handle()
 };
-const prettyJson = (obj, options) => formatJson(obj, 0, options?.handleMultiline);
 
 //#endregion
-//#region src/core/tracing/index.ts
-const tracer = () => {};
-const LogLevel = {
-	DISABLED: "DISABLED",
-	INFO: "INFO",
-	LOG: "LOG",
-	WARN: "WARN",
-	ERROR: "ERROR"
-};
-const LogStyle = {
-	RAW: "RAW",
-	PRETTY: "PRETTY"
+//#region src/core/query/selectors.ts
+const firstOrNull = async (getResult) => {
+	const result = await getResult;
+	return result.rows.length > 0 ? result.rows[0] ?? null : null;
 };
-const getEnvVariable = (name) => {
-	try {
-		if (typeof process !== "undefined" && process.env) return process.env[name];
-		return;
-	} catch {
-		return;
-	}
+const first = async (getResult) => {
+	const result = await getResult;
+	if (result.rows.length === 0) throw new Error("Query didn't return any result");
+	return result.rows[0];
 };
-const shouldLog = (logLevel) => {
-	const definedLogLevel = getEnvVariable("DUMBO_LOG_LEVEL") ?? LogLevel.ERROR;
-	if (definedLogLevel === LogLevel.ERROR && logLevel === LogLevel.ERROR) return true;
-	if (definedLogLevel === LogLevel.WARN && [LogLevel.ERROR, LogLevel.WARN].includes(logLevel)) return true;
-	if (definedLogLevel === LogLevel.LOG && [
-		LogLevel.ERROR,
-		LogLevel.WARN,
-		LogLevel.LOG
-	].includes(logLevel)) return true;
-	if (definedLogLevel === LogLevel.INFO && [
-		LogLevel.ERROR,
-		LogLevel.WARN,
-		LogLevel.LOG,
-		LogLevel.INFO
-	].includes(logLevel)) return true;
-	return false;
+const singleOrNull = async (getResult) => {
+	const result = await getResult;
+	if (result.rows.length > 1) throw new Error("Query had more than one result");
+	return result.rows.length > 0 ? result.rows[0] ?? null : null;
 };
-const nulloTraceEventRecorder = () => {};
-const getTraceEventFormatter = (logStyle, serializer = JSONSerializer) => (event) => {
-	switch (logStyle) {
-		case "RAW": return serializer.serialize(event);
-		case "PRETTY": return prettyJson(event, { handleMultiline: true });
-	}
+const single = async (getResult) => {
+	const result = await getResult;
+	if (result.rows.length === 0) throw new Error("Query didn't return any result");
+	if (result.rows.length > 1) throw new Error("Query had more than one result");
+	return result.rows[0];
 };
-const getTraceEventRecorder = (logLevel, logStyle) => {
-	const format = getTraceEventFormatter(logStyle);
-	switch (logLevel) {
-		case "DISABLED": return nulloTraceEventRecorder;
-		case "INFO": return (event) => console.info(format(event));
-		case "LOG": return (event) => console.log(format(event));
-		case "WARN": return (event) => console.warn(format(event));
-		case "ERROR": return (event) => console.error(format(event));
-	}
+const count = async (getResult) => {
+	const result = await single(getResult);
+	return Number(result.count);
 };
-const recordTraceEvent = (logLevel, eventName, attributes) => {
-	if (!shouldLog(LogLevel.LOG)) return;
-	const event = {
-		name: eventName,
-		timestamp: (/* @__PURE__ */ new Date()).getTime(),
-		...attributes
-	};
-	getTraceEventRecorder(logLevel, getEnvVariable("DUMBO_LOG_STYLE") ?? "RAW")(event);
+const exists = async (getResult) => {
+	const result = await single(getResult);
+	return result.exists === true || result.exists === 1;
 };
-tracer.info = (eventName, attributes) => recordTraceEvent(LogLevel.INFO, eventName, attributes);
-tracer.warn = (eventName, attributes) => recordTraceEvent(LogLevel.WARN, eventName, attributes);
-tracer.log = (eventName, attributes) => recordTraceEvent(LogLevel.LOG, eventName, attributes);
-tracer.error = (eventName, attributes) => recordTraceEvent(LogLevel.ERROR, eventName, attributes);
-
-//#endregion
-//#region src/core/schema/sqlMigration.ts
-const sqlMigration = (name, sqls) => ({
-	name,
-	sqls
-});
 
 //#endregion
-//#region src/core/schema/migrators/schemaComponentMigrator.ts
-const { AutoIncrement, Varchar, Timestamp } = SQL.column.type;
-const migrationTableSQL = SQL`
-  CREATE TABLE IF NOT EXISTS dmb_migrations (
-    id ${AutoIncrement({ primaryKey: true })},
-    name ${Varchar(255)} NOT NULL UNIQUE,
-    application ${Varchar(255)} NOT NULL DEFAULT 'default',
-    sql_hash ${Varchar(64)} NOT NULL,
-    timestamp ${Timestamp} NOT NULL DEFAULT CURRENT_TIMESTAMP
-  );
-`;
-const migrationTableSchemaComponent = schemaComponent("dumbo:schema-component:migrations-table", { migrations: [sqlMigration("dumbo:migrationTable:001", [migrationTableSQL])] });
-const SchemaComponentMigrator = (component, dumbo) => {
-	const completedMigrations = [];
+//#region src/core/schema/schemaComponent.ts
+const schemaComponent = (key, options) => {
+	const componentsMap = new Map(options.components?.map((comp) => [comp.schemaComponentKey, comp]));
+	const migrations = [...options.migrations ?? []];
 	return {
-		component,
-		run: async (options) => {
-			const pendingMigrations = component.migrations.filter((m) => !completedMigrations.includes(`${component.schemaComponentKey}:${m.name}`));
-			if (pendingMigrations.length === 0) return;
-			await runSQLMigrations(dumbo, pendingMigrations, options);
-			completedMigrations.push(...pendingMigrations.map((m) => `${component.schemaComponentKey}:${m.name}`));
+		schemaComponentKey: key,
+		components: componentsMap,
+		get migrations() {
+			return [...migrations, ...Array.from(componentsMap.values()).flatMap((c) => c.migrations)];
+		},
+		addComponent: (component) => {
+			componentsMap.set(component.schemaComponentKey, component);
+			migrations.push(...component.migrations);
+			return component;
+		},
+		addMigration: (migration) => {
+			migrations.push(migration);
 		}
 	};
 };
-
-//#endregion
-//#region src/core/schema/migrators/migrator.ts
-const MIGRATIONS_LOCK_ID = 999956789;
-const defaultMigratorOptions = globalThis.defaultMigratorOptions = globalThis.defaultMigratorOptions ?? {};
-const registerDefaultMigratorOptions = (databaseType, options) => {
-	defaultMigratorOptions[databaseType] = options;
+const isSchemaComponentOfType = (component, prefix) => component.schemaComponentKey.startsWith(prefix);
+const filterSchemaComponentsOfType = (components, prefix) => mapSchemaComponentsOfType(components, prefix);
+const mapSchemaComponentsOfType = (components, prefix, keyMapper) => new Map(Array.from(components.entries()).filter(([urn]) => urn.startsWith(prefix)).map(([urn, component]) => [keyMapper ? keyMapper(component) : urn, component]));
+const findSchemaComponentsOfType = (root, prefix) => {
+	const results = [];
+	const traverse = (component) => {
+		if (component.schemaComponentKey.startsWith(prefix)) results.push(component);
+		for (const child of component.components.values()) traverse(child);
+	};
+	traverse(root);
+	return results;
 };
-const getDefaultMigratorOptionsFromRegistry = (databaseType) => {
-	if (!defaultMigratorOptions[databaseType]) throw new Error(`No default migrator options registered for database type: ${databaseType}`);
-	return defaultMigratorOptions[databaseType];
+
+//#endregion
+//#region src/core/schema/components/columnSchemaComponent.ts
+const ColumnURNType = "sc:dumbo:column";
+const ColumnURN = ({ name }) => `${ColumnURNType}:${name}`;
+const columnSchemaComponent = (params) => {
+	const { columnName, type, notNull, unique, primaryKey, default: defaultValue, ...schemaOptions } = params;
+	return {
+		...schemaComponent(ColumnURN({ name: columnName }), schemaOptions),
+		columnName,
+		notNull,
+		unique,
+		primaryKey,
+		defaultValue,
+		sqlTokenType: "SQL_COLUMN",
+		name: columnName,
+		type
+	};
 };
-const runSQLMigrations = (pool, migrations, partialOptions) => pool.withTransaction(async ({ execute }) => {
-	const databaseType = fromDatabaseDriverType(pool.driverType).databaseType;
-	const defaultOptions = getDefaultMigratorOptionsFromRegistry(databaseType);
-	partialOptions ??= {};
-	const options = {
-		...defaultOptions,
-		...partialOptions,
-		schema: {
-			...defaultOptions.schema,
-			...partialOptions?.schema ?? {}
-		},
-		lock: {
-			...defaultOptions.lock,
-			...partialOptions?.lock,
-			options: {
-				lockId: MIGRATIONS_LOCK_ID,
-				...defaultOptions.lock?.options,
-				...partialOptions?.lock?.options
-			}
+
+//#endregion
+//#region src/core/schema/components/indexSchemaComponent.ts
+const IndexURNType = "sc:dumbo:index";
+const IndexURN = ({ name }) => `${IndexURNType}:${name}`;
+const indexSchemaComponent = ({ indexName, columnNames, isUnique, ...migrationsOrComponents }) => {
+	return {
+		...schemaComponent(IndexURN({ name: indexName }), {
+			migrations: migrationsOrComponents.migrations ?? [],
+			components: [...migrationsOrComponents.components ?? []]
+		}),
+		indexName,
+		get columnNames() {
+			return columnNames;
 		},
-		dryRun: defaultOptions.dryRun ?? partialOptions?.dryRun,
-		ignoreMigrationHashMismatch: defaultOptions.ignoreMigrationHashMismatch ?? partialOptions?.ignoreMigrationHashMismatch,
-		migrationTimeoutMs: defaultOptions.migrationTimeoutMs ?? partialOptions?.migrationTimeoutMs
-	};
-	const { databaseLock: _, ...rest } = options.lock ?? {};
-	const databaseLock = options.lock?.databaseLock ?? NoDatabaseLock;
-	const lockOptions = {
-		lockId: MIGRATIONS_LOCK_ID,
-		...rest
-	};
-	const coreMigrations = (options.schema?.migrationTable ?? migrationTableSchemaComponent).migrations;
-	const result = {
-		applied: [],
-		skipped: []
+		addColumn: (column) => columnNames.push(typeof column === "string" ? column : column.columnName),
+		isUnique
 	};
-	await databaseLock.withAcquire(execute, async () => {
-		for (const migration of coreMigrations) await execute.batchCommand(migration.sqls, { timeoutMs: options.migrationTimeoutMs });
-		for (const migration of migrations) if (await runSQLMigration(databaseType, execute, migration, {
-			ignoreMigrationHashMismatch: options.ignoreMigrationHashMismatch ?? false,
-			migrationTimeoutMs: options.migrationTimeoutMs
-		})) result.applied.push(migration);
-		else result.skipped.push(migration);
-	}, lockOptions);
+};
+
+//#endregion
+//#region src/core/schema/components/tableSchemaComponent.ts
+const TableURNType = "sc:dumbo:table";
+const TableURN = ({ name }) => `${TableURNType}:${name}`;
+const tableSchemaComponent = ({ tableName, columns, primaryKey, relationships, ...migrationsOrComponents }) => {
+	columns ??= {};
+	relationships ??= {};
+	const base = schemaComponent(TableURN({ name: tableName }), {
+		migrations: migrationsOrComponents.migrations ?? [],
+		components: [...migrationsOrComponents.components ?? [], ...Object.values(columns)]
+	});
 	return {
-		success: options.dryRun ? false : true,
-		result
+		...base,
+		tableName,
+		primaryKey: primaryKey ?? [],
+		relationships,
+		get columns() {
+			const columnsMap = mapSchemaComponentsOfType(base.components, ColumnURNType, (c) => c.columnName);
+			return Object.assign(columnsMap, columns);
+		},
+		get indexes() {
+			return mapSchemaComponentsOfType(base.components, IndexURNType, (c) => c.indexName);
+		},
+		addColumn: (column) => base.addComponent(column),
+		addIndex: (index) => base.addComponent(index)
 	};
-});
-const runSQLMigration = async (databaseType, execute, migration, options) => {
-	const sqls = combineMigrations(migration);
-	const sqlHash = await getMigrationHash(migration, getFormatter(databaseType));
-	try {
-		const newMigration = {
-			name: migration.name,
-			sqlHash
-		};
-		const checkResult = await ensureMigrationWasNotAppliedYet(execute, newMigration);
-		if (checkResult.exists === true) {
-			if (checkResult.hashesMatch === true) {
-				tracer.info("migration-already-applied", { migrationName: migration.name });
-				return false;
-			}
-			if (options?.ignoreMigrationHashMismatch !== true) throw new Error(`Migration hash mismatch for "${migration.name}". Aborting migration.`);
-			tracer.warn("migration-hash-mismatch", {
-				migrationName: migration.name,
-				expectedHash: sqlHash,
-				actualHash: checkResult.hashFromDB
-			});
-			await updateMigrationHash(execute, newMigration);
-			return false;
-		}
-		await execute.batchCommand(sqls, { timeoutMs: options?.migrationTimeoutMs });
-		await recordMigration(execute, newMigration);
-		return true;
-	} catch (error) {
-		tracer.error("migration-error", {
-			migationName: migration.name,
-			error
-		});
-		throw error;
-	}
-};
-const getMigrationHash = async (sqlMigration, sqlFormatter) => {
-	const content = sqlFormatter.describe(sqlMigration.sqls, { serializer: JSONSerializer });
-	const data = new TextEncoder().encode(content);
-	const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-	return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
 };
-const combineMigrations = (...migration) => migration.flatMap((m) => m.sqls);
-const ensureMigrationWasNotAppliedYet = async (execute, migration) => {
-	const result = await singleOrNull(execute.query(SQL`SELECT sql_hash as "sqlHash" FROM dmb_migrations WHERE name = ${migration.name}`));
-	if (result === null) return { exists: false };
-	const { sqlHash } = result;
+
+//#endregion
+//#region src/core/schema/components/databaseSchemaSchemaComponent.ts
+const DatabaseSchemaURNType = "sc:dumbo:database_schema";
+const DatabaseSchemaURN = ({ name }) => `${DatabaseSchemaURNType}:${name}`;
+const databaseSchemaSchemaComponent = ({ schemaName, tables, ...migrationsOrComponents }) => {
+	const base = schemaComponent(DatabaseSchemaURN({ name: schemaName }), {
+		migrations: migrationsOrComponents.migrations ?? [],
+		components: [...migrationsOrComponents.components ?? [], ...Object.values(tables ?? {})]
+	});
 	return {
-		exists: true,
-		hashesMatch: sqlHash === migration.sqlHash,
-		hashFromDB: sqlHash
+		...base,
+		schemaName,
+		get tables() {
+			const tablesMap = mapSchemaComponentsOfType(base.components, TableURNType, (c) => c.tableName);
+			return Object.assign(tablesMap, tables);
+		},
+		addTable: (table) => base.addComponent(typeof table === "string" ? tableSchemaComponent({ tableName: table }) : table)
 	};
 };
-const recordMigration = async (execute, migration) => {
-	await execute.command(SQL`
-      INSERT INTO dmb_migrations (name, sql_hash)
-      VALUES (${migration.name}, ${migration.sqlHash})`);
-};
-const updateMigrationHash = async (execute, migration) => {
-	await execute.command(SQL`
-      UPDATE dmb_migrations
-      SET sql_hash = ${migration.sqlHash}, timestamp = ${/* @__PURE__ */ new Date()}
-      WHERE name = ${migration.name}
-      `);
+
+//#endregion
+//#region src/core/schema/components/databaseSchemaComponent.ts
+const DatabaseURNType = "sc:dumbo:database";
+const DatabaseURN = ({ name }) => `${DatabaseURNType}:${name}`;
+const databaseSchemaComponent = ({ databaseName, schemas, ...migrationsOrComponents }) => {
+	schemas ??= {};
+	const base = schemaComponent(DatabaseURN({ name: databaseName }), {
+		migrations: migrationsOrComponents.migrations ?? [],
+		components: [...migrationsOrComponents.components ?? [], ...Object.values(schemas)]
+	});
+	return {
+		...base,
+		databaseName,
+		get schemas() {
+			const schemasMap = mapSchemaComponentsOfType(base.components, DatabaseSchemaURNType, (c) => c.schemaName);
+			return Object.assign(schemasMap, schemas);
+		},
+		addSchema: (schema) => base.addComponent(typeof schema === "string" ? databaseSchemaSchemaComponent({ schemaName: schema }) : schema)
+	};
 };
 
 //#endregion
-//#region src/core/errors/index.ts
-const isNumber = (val) => typeof val === "number" && val === val;
-const isString = (val) => typeof val === "string";
-var DumboError = class DumboError extends Error {
-	static ErrorCode = 500;
-	static ErrorType = "DumboError";
-	errorCode;
-	errorType;
-	innerError;
-	constructor(options) {
-		const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : DumboError.ErrorCode;
-		const errorType = options && typeof options === "object" && "errorType" in options ? options.errorType ?? DumboError.ErrorType : DumboError.ErrorType;
-		const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during DumboError processing`;
-		const innerError = options && typeof options === "object" && "innerError" in options ? options.innerError : void 0;
-		super(message, { cause: innerError });
-		this.errorCode = errorCode;
-		this.errorType = errorType;
-		this.innerError = innerError;
-		Object.setPrototypeOf(this, DumboError.prototype);
-	}
-	static isInstanceOf(error, options) {
-		if (typeof error !== "object" || error === null || !("errorCode" in error) || !isNumber(error.errorCode) || !("errorType" in error) || !isString(error.errorType)) return false;
-		if (!options) return true;
-		if (options.errorCode !== void 0 && error.errorCode !== options.errorCode) return false;
-		if (options.errorType !== void 0 && error.errorType !== options.errorType) return false;
-		return true;
+//#region src/core/schema/components/index.ts
+const schemaComponentURN = {
+	database: DatabaseURN,
+	schema: DatabaseSchemaURN,
+	table: TableURN,
+	column: ColumnURN,
+	index: IndexURN,
+	extractName: (urn) => {
+		const parts = urn.split(":");
+		return parts[parts.length - 1] || "";
 	}
 };
-var ConcurrencyError = class ConcurrencyError extends DumboError {
-	static ErrorCode = 412;
-	static ErrorType = "ConcurrencyError";
-	constructor(message, innerError) {
-		super({
-			errorCode: ConcurrencyError.ErrorCode,
-			errorType: ConcurrencyError.ErrorType,
-			message: message ?? `Expected document state does not match current one!`,
-			innerError
-		});
-		Object.setPrototypeOf(this, ConcurrencyError.prototype);
-	}
+
+//#endregion
+//#region src/core/schema/databaseMetadata/databaseMetadata.ts
+const DumboDatabaseMetadataRegistry = () => {
+	const infos = /* @__PURE__ */ new Map();
+	const register = (databaseType, info) => {
+		const entry = infos.get(databaseType);
+		if (entry && (typeof entry !== "function" || typeof info === "function")) return;
+		infos.set(databaseType, info);
+	};
+	const tryResolve = async (databaseType) => {
+		const entry = infos.get(databaseType);
+		if (!entry) return null;
+		if (typeof entry !== "function") return entry;
+		const resolved = await entry();
+		register(databaseType, resolved);
+		return resolved;
+	};
+	const tryGet = (databaseType) => {
+		const entry = infos.get(databaseType);
+		return entry && typeof entry !== "function" ? entry : null;
+	};
+	const has = (databaseType) => infos.has(databaseType);
+	return {
+		register,
+		tryResolve,
+		tryGet,
+		has,
+		get databaseTypes() {
+			return Array.from(infos.keys());
+		}
+	};
 };
-var TransientDatabaseError = class TransientDatabaseError extends DumboError {
-	static ErrorCode = 503;
-	static ErrorType = "TransientDatabaseError";
-	constructor(message, innerError) {
-		super({
-			errorCode: TransientDatabaseError.ErrorCode,
-			errorType: TransientDatabaseError.ErrorType,
-			message: message ?? `A transient error occurred during database operation. Retrying the operation might succeed.`,
-			innerError
-		});
-		Object.setPrototypeOf(this, TransientDatabaseError.prototype);
-	}
+const dumboDatabaseMetadataRegistry = globalThis.dumboDatabaseMetadataRegistry = globalThis.dumboDatabaseMetadataRegistry ?? DumboDatabaseMetadataRegistry();
+const getDatabaseMetadata = (driverType) => {
+	const { databaseType } = fromDatabaseDriverType(driverType);
+	return dumboDatabaseMetadataRegistry.tryGet(databaseType);
 };
-var ConnectionError = class ConnectionError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "ConnectionError";
-	constructor(message, innerError) {
-		super(message ?? `A connection error occurred during database operation.`, innerError);
-		this.errorType = ConnectionError.ErrorType;
-		Object.setPrototypeOf(this, ConnectionError.prototype);
-	}
+const resolveDatabaseMetadata = async (driverType, driverOverride) => {
+	if (driverOverride) return driverOverride;
+	const { databaseType } = fromDatabaseDriverType(driverType);
+	return dumboDatabaseMetadataRegistry.tryResolve(databaseType);
 };
-var SerializationError = class SerializationError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "SerializationError";
-	constructor(message, innerError) {
-		super(message ?? `A serialization failure occurred. The transaction can be retried.`, innerError);
-		this.errorType = SerializationError.ErrorType;
-		Object.setPrototypeOf(this, SerializationError.prototype);
-	}
+const getDefaultDatabase = (driverType) => {
+	return getDatabaseMetadata(driverType)?.defaultDatabaseName;
 };
-var DeadlockError = class DeadlockError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "DeadlockError";
-	constructor(message, innerError) {
-		super(message ?? `A deadlock was detected. The transaction can be retried.`, innerError);
-		this.errorType = DeadlockError.ErrorType;
-		Object.setPrototypeOf(this, DeadlockError.prototype);
-	}
+const getDefaultDatabaseAsync = async (driverType) => {
+	return (await resolveDatabaseMetadata(driverType))?.defaultDatabaseName;
 };
-var LockNotAvailableError = class LockNotAvailableError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "LockNotAvailableError";
-	constructor(message, innerError) {
-		super(message ?? `The requested lock is not available.`, innerError);
-		this.errorType = LockNotAvailableError.ErrorType;
-		Object.setPrototypeOf(this, LockNotAvailableError.prototype);
-	}
+
+//#endregion
+//#region src/core/schema/dumboSchema/dumboSchema.ts
+const DEFAULT_DATABASE_NAME = "__default_database__";
+const DEFAULT_DATABASE_SCHEMA_NAME = "__default_database_schema__";
+const dumboColumn = (name, type, options) => columnSchemaComponent({
+	columnName: name,
+	type,
+	...options
+});
+const dumboIndex = (name, columnNames, options) => indexSchemaComponent({
+	indexName: name,
+	columnNames,
+	isUnique: options?.unique ?? false,
+	...options
+});
+const dumboTable = (name, definition) => {
+	const { columns, indexes, primaryKey, relationships, ...options } = definition;
+	const components = [...indexes ? Object.values(indexes) : []];
+	return tableSchemaComponent({
+		tableName: name,
+		columns: columns ?? {},
+		primaryKey: primaryKey ?? [],
+		...relationships !== void 0 ? { relationships } : {},
+		components,
+		...options
+	});
 };
-var InsufficientResourcesError = class InsufficientResourcesError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "InsufficientResourcesError";
-	constructor(message, innerError) {
-		super(message ?? `Insufficient resources to complete the database operation (e.g. disk full, out of memory, too many connections).`, innerError);
-		this.errorType = InsufficientResourcesError.ErrorType;
-		Object.setPrototypeOf(this, InsufficientResourcesError.prototype);
-	}
+function dumboDatabaseSchema(nameOrTables, tables, options) {
+	return databaseSchemaSchemaComponent({
+		schemaName: typeof nameOrTables === "string" ? nameOrTables : DEFAULT_DATABASE_SCHEMA_NAME,
+		tables: (typeof nameOrTables === "string" ? tables : nameOrTables) ?? {},
+		...options
+	});
+}
+dumboDatabaseSchema.from = (schemaName, tableNames) => {
+	const tables = tableNames.reduce((acc, tableName) => {
+		acc[tableName] = dumboTable(tableName, {});
+		return acc;
+	}, {});
+	return schemaName ? dumboDatabaseSchema(schemaName, tables) : dumboDatabaseSchema(tables);
 };
-var SystemError = class SystemError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "SystemError";
-	constructor(message, innerError) {
-		super(message ?? `A system-level error occurred (e.g. I/O error).`, innerError);
-		this.errorType = SystemError.ErrorType;
-		Object.setPrototypeOf(this, SystemError.prototype);
-	}
+function dumboDatabase(nameOrSchemas, schemasOrOptions, options) {
+	const databaseName = typeof nameOrSchemas === "string" ? nameOrSchemas : DEFAULT_DATABASE_NAME;
+	const schemasOrSchema = typeof nameOrSchemas === "string" ? schemasOrOptions ?? {} : nameOrSchemas;
+	return databaseSchemaComponent({
+		databaseName,
+		schemas: "schemaComponentKey" in schemasOrSchema && isSchemaComponentOfType(schemasOrSchema, "sc:dumbo:database_schema") ? { [DEFAULT_DATABASE_SCHEMA_NAME]: schemasOrSchema } : schemasOrSchema,
+		...typeof nameOrSchemas === "string" ? options : schemasOrOptions
+	});
+}
+dumboDatabase.from = (databaseName, schemaNames) => {
+	const schemas = schemaNames.reduce((acc, schemaName) => {
+		acc[schemaName] = dumboDatabaseSchema(schemaName, {});
+		return acc;
+	}, {});
+	return databaseName ? dumboDatabase(databaseName, schemas) : dumboDatabase(schemas);
 };
-var AdminShutdownError = class AdminShutdownError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "AdminShutdownError";
-	constructor(message, innerError) {
-		super(message ?? `The database server is shutting down or restarting.`, innerError);
-		this.errorType = AdminShutdownError.ErrorType;
-		Object.setPrototypeOf(this, AdminShutdownError.prototype);
-	}
+dumboDatabase.defaultName = DEFAULT_DATABASE_NAME;
+dumboDatabaseSchema.defaultName = DEFAULT_DATABASE_SCHEMA_NAME;
+const dumboSchema = {
+	database: dumboDatabase,
+	schema: dumboDatabaseSchema,
+	table: dumboTable,
+	column: dumboColumn,
+	index: dumboIndex
 };
-var QueryCanceledError = class QueryCanceledError extends TransientDatabaseError {
-	static ErrorCode = 503;
-	static ErrorType = "QueryCanceledError";
-	constructor(message, innerError) {
-		super(message ?? `The query was canceled, e.g. due to statement timeout or user request.`, innerError);
-		this.errorType = QueryCanceledError.ErrorType;
-		Object.setPrototypeOf(this, QueryCanceledError.prototype);
-	}
+
+//#endregion
+//#region src/core/serializer/json/index.ts
+const bigIntReplacer = (_key, value) => {
+	return typeof value === "bigint" ? value.toString() : value;
 };
-var IntegrityConstraintViolationError = class IntegrityConstraintViolationError extends DumboError {
-	static ErrorCode = 409;
-	static ErrorType = "IntegrityConstraintViolationError";
-	constructor(message, innerError) {
-		super({
-			errorCode: IntegrityConstraintViolationError.ErrorCode,
-			errorType: IntegrityConstraintViolationError.ErrorType,
-			message: message ?? `An integrity constraint violation occurred!`,
-			innerError
-		});
-		Object.setPrototypeOf(this, IntegrityConstraintViolationError.prototype);
-	}
+const dateReplacer = (_key, value) => {
+	return value instanceof Date ? value.toISOString() : value;
 };
-var UniqueConstraintError = class UniqueConstraintError extends IntegrityConstraintViolationError {
-	static ErrorCode = 409;
-	static ErrorType = "UniqueConstraintError";
-	constructor(message, innerError) {
-		super(message ?? `Unique constraint violation occurred!`, innerError);
-		this.errorType = UniqueConstraintError.ErrorType;
-		Object.setPrototypeOf(this, UniqueConstraintError.prototype);
-	}
+const isFirstLetterNumeric = (str) => {
+	const c = str.charCodeAt(0);
+	return c >= 48 && c <= 57;
 };
-var ForeignKeyViolationError = class ForeignKeyViolationError extends IntegrityConstraintViolationError {
-	static ErrorCode = 409;
-	static ErrorType = "ForeignKeyViolationError";
-	constructor(message, innerError) {
-		super(message ?? `Foreign key constraint violation occurred!`, innerError);
-		this.errorType = ForeignKeyViolationError.ErrorType;
-		Object.setPrototypeOf(this, ForeignKeyViolationError.prototype);
-	}
+const isFirstLetterNumericOrMinus = (str) => {
+	const c = str.charCodeAt(0);
+	return c >= 48 && c <= 57 || c === 45;
 };
-var NotNullViolationError = class NotNullViolationError extends IntegrityConstraintViolationError {
-	static ErrorCode = 409;
-	static ErrorType = "NotNullViolationError";
-	constructor(message, innerError) {
-		super(message ?? `NOT NULL constraint violation occurred!`, innerError);
-		this.errorType = NotNullViolationError.ErrorType;
-		Object.setPrototypeOf(this, NotNullViolationError.prototype);
+const bigIntReviver = (_key, value, context) => {
+	if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) try {
+		return BigInt(context?.source ?? value.toString());
+	} catch {
+		return value;
+	}
+	if (typeof value === "string" && value.length > 15) {
+		if (isFirstLetterNumericOrMinus(value)) {
+			const num = Number(value);
+			if (Number.isFinite(num) && !Number.isSafeInteger(num)) try {
+				return BigInt(value);
+			} catch {}
+		}
 	}
+	return value;
 };
-var CheckViolationError = class CheckViolationError extends IntegrityConstraintViolationError {
-	static ErrorCode = 409;
-	static ErrorType = "CheckViolationError";
-	constructor(message, innerError) {
-		super(message ?? `CHECK constraint violation occurred!`, innerError);
-		this.errorType = CheckViolationError.ErrorType;
-		Object.setPrototypeOf(this, CheckViolationError.prototype);
-	}
-};
-var ExclusionViolationError = class ExclusionViolationError extends IntegrityConstraintViolationError {
-	static ErrorCode = 409;
-	static ErrorType = "ExclusionViolationError";
-	constructor(message, innerError) {
-		super(message ?? `Exclusion constraint violation occurred!`, innerError);
-		this.errorType = ExclusionViolationError.ErrorType;
-		Object.setPrototypeOf(this, ExclusionViolationError.prototype);
-	}
-};
-var DataError = class DataError extends DumboError {
-	static ErrorCode = 400;
-	static ErrorType = "DataError";
-	constructor(message, innerError) {
-		super({
-			errorCode: DataError.ErrorCode,
-			errorType: DataError.ErrorType,
-			message: message ?? `A data error occurred (e.g. invalid value, type mismatch).`,
-			innerError
-		});
-		Object.setPrototypeOf(this, DataError.prototype);
+const dateReviver = (_key, value) => {
+	if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
+		const date = new Date(value);
+		if (!isNaN(date.getTime())) return date;
 	}
+	return value;
 };
-var InvalidOperationError = class InvalidOperationError extends DumboError {
-	static ErrorCode = 400;
-	static ErrorType = "InvalidOperationError";
-	constructor(message, innerError) {
-		super({
-			errorCode: InvalidOperationError.ErrorCode,
-			errorType: InvalidOperationError.ErrorType,
-			message: message ?? `Invalid operation (e.g. syntax error, insufficient privileges, undefined table).`,
-			innerError
-		});
-		Object.setPrototypeOf(this, InvalidOperationError.prototype);
-	}
+const composeJSONReplacers = (...replacers) => {
+	const filteredReplacers = replacers.filter((r) => r !== void 0);
+	if (filteredReplacers.length === 0) return void 0;
+	return (key, value) => filteredReplacers.reduce((accValue, replacer) => replacer(key, accValue), value);
 };
-
-//#endregion
-//#region src/core/execute/execute.ts
-const mapColumnToJSON = (column, serializer, options) => ({ [column]: (value) => {
-	if (typeof value === "string") try {
-		return serializer.deserialize(value, options);
-	} catch {}
-	return value;
-} });
-const mapColumnToBigint = (column) => ({ [column]: (value) => {
-	if (typeof value === "number" || typeof value === "string") return BigInt(value);
-	return value;
-} });
-const mapColumnToDate = (column) => ({ [column]: (value) => {
-	if (typeof value === "number" || typeof value === "string") return new Date(value);
-	return value;
-} });
-const mapSQLQueryResult = (result, mapping) => {
-	if (typeof result !== "object" || result === null) return result;
-	const mappedResult = { ...result };
-	for (const column of Object.keys(mapping)) if (column in mappedResult) mappedResult[column] = mapping[column](mappedResult[column]);
-	return mappedResult;
+const composeJSONRevivers = (...revivers) => {
+	const filteredRevivers = revivers.filter((r) => r !== void 0);
+	if (filteredRevivers.length === 0) return void 0;
+	return (key, value, context) => filteredRevivers.reduce((accValue, reviver) => reviver(key, accValue, context), value);
 };
-var BatchCommandNoChangesError = class BatchCommandNoChangesError extends DumboError {
-	statementIndex;
-	constructor(statementIndex) {
-		super({
-			errorCode: 409,
-			message: `Batch command at index ${statementIndex} affected no rows`
-		});
-		this.name = "BatchCommandNoChangesError";
-		this.statementIndex = statementIndex;
-		Object.setPrototypeOf(this, BatchCommandNoChangesError.prototype);
-	}
+const JSONReplacer = (opts) => composeJSONReplacers(opts?.replacer, opts?.failOnBigIntSerialization !== true ? JSONReplacers.bigInt : void 0, opts?.useDefaultDateSerialization !== true ? JSONReplacers.date : void 0);
+const JSONReviver = (opts) => composeJSONRevivers(opts?.reviver, opts?.parseBigInts === true ? JSONRevivers.bigInt : void 0, opts?.parseDates === true ? JSONRevivers.date : void 0);
+const JSONReplacers = {
+	bigInt: bigIntReplacer,
+	date: dateReplacer
 };
-const sqlExecutor = (sqlExecutor, options) => ({
-	query: (sql, queryOptions) => executeInNewDbClient((client) => sqlExecutor.query(client, sql, queryOptions), options),
-	batchQuery: (sqls, queryOptions) => executeInNewDbClient((client) => sqlExecutor.batchQuery(client, sqls, queryOptions), options),
-	command: (sql, commandOptions) => executeInNewDbClient((client) => sqlExecutor.command(client, sql, commandOptions), options),
-	batchCommand: (sqls, commandOptions) => executeInNewDbClient((client) => sqlExecutor.batchCommand(client, sqls, commandOptions), options)
-});
-const sqlExecutorInNewConnection = (options) => ({
-	query: (sql, queryOptions) => executeInNewConnection((connection) => connection.execute.query(sql, queryOptions), options),
-	batchQuery: (sqls, queryOptions) => executeInNewConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), options),
-	command: (sql, commandOptions) => executeInNewConnection((connection) => connection.execute.command(sql, commandOptions), options),
-	batchCommand: (sqls, commandOptions) => executeInNewConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), options)
-});
-const sqlExecutorInAmbientConnection = (options) => ({
-	query: (sql, queryOptions) => executeInAmbientConnection((connection) => connection.execute.query(sql, queryOptions), options),
-	batchQuery: (sqls, queryOptions) => executeInAmbientConnection((connection) => connection.execute.batchQuery(sqls, queryOptions), options),
-	command: (sql, commandOptions) => executeInAmbientConnection((connection) => connection.execute.command(sql, commandOptions), options),
-	batchCommand: (sqls, commandOptions) => executeInAmbientConnection((connection) => connection.execute.batchCommand(sqls, commandOptions), options)
-});
-const executeInNewDbClient = async (handle, options) => {
-	const { connect, close } = options;
-	const client = await connect();
-	try {
-		return await handle(client);
-	} catch (error) {
-		if (close) await close(client, error);
-		throw error;
-	}
+const JSONRevivers = {
+	bigInt: bigIntReviver,
+	date: dateReviver
 };
-const executeInNewConnection = async (handle, options) => {
-	const connection = await options.connection();
-	try {
-		return await handle(connection);
-	} finally {
-		await connection.close();
-	}
+const jsonSerializer = (options) => {
+	const defaultReplacer = JSONReplacer(options);
+	const defaultReviver = JSONReviver(options);
+	return {
+		serialize: (object, serializerOptions) => JSON.stringify(object, serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer),
+		deserialize: (payload, deserializerOptions) => JSON.parse(payload, deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver)
+	};
 };
-const executeInAmbientConnection = async (handle, options) => {
-	const connection = await options.connection();
-	try {
-		return await handle(connection);
-	} finally {}
+const JSONSerializer = Object.assign(jsonSerializer(), { from: (options) => options?.serialization?.serializer ?? (options?.serialization?.options ? jsonSerializer(options?.serialization?.options) : JSONSerializer) });
+const JSONCodec = (options) => {
+	const serializer = "serializer" in options ? options.serializer : jsonSerializer("serializerOptions" in options ? options.serializerOptions : void 0);
+	const upcast = options.upcast ?? ((doc) => doc);
+	const downcast = options.downcast ?? ((doc) => doc);
+	return {
+		decode: (payload, decodeOptions) => {
+			return upcast(decodeOptions ? serializer.deserialize(payload, decodeOptions) : serializer.deserialize(payload));
+		},
+		encode: (object, encodeOptions) => {
+			const downcasted = downcast(object);
+			return encodeOptions ? serializer.serialize(downcasted, encodeOptions) : serializer.serialize(downcasted);
+		}
+	};
 };
 
 //#endregion
-//#region src/core/connections/transaction.ts
-const toTransactionResult = (transactionResult) => transactionResult !== void 0 && transactionResult !== null && typeof transactionResult === "object" && "success" in transactionResult ? transactionResult : {
-	success: true,
-	result: transactionResult
-};
-const executeInTransaction = async (transaction, handle) => {
-	await transaction.begin();
-	try {
-		const { success, result } = toTransactionResult(await handle(transaction));
-		if (success) await transaction.commit();
-		else await transaction.rollback();
-		return result;
-	} catch (e) {
-		await transaction.rollback();
-		throw e;
-	}
-};
-const transactionFactoryWithDbClient = (connect, initTransaction) => {
-	let currentTransaction = void 0;
-	const getOrInitCurrentTransaction = (options) => currentTransaction ?? (currentTransaction = initTransaction(connect(), {
-		close: () => {
-			currentTransaction = void 0;
-			return Promise.resolve();
-		},
-		...options ?? {}
-	}));
+//#region src/core/sql/parametrizedSQL/parametrizedSQL.ts
+const ParametrizedSQLBuilder = ({ mapParamPlaceholder }) => {
+	const sql = [];
+	const params = [];
 	return {
-		transaction: getOrInitCurrentTransaction,
-		withTransaction: (handle, options) => executeInTransaction(getOrInitCurrentTransaction(options), handle)
+		addSQL(str) {
+			sql.push(str);
+			return this;
+		},
+		addParam(value) {
+			sql.push(mapParamPlaceholder(params.length, value));
+			params.push(value);
+			return this;
+		},
+		addParams(values) {
+			const placeholders = values.map((value, i) => mapParamPlaceholder(params.length + i, value));
+			this.addSQL(`${placeholders.join(", ")}`);
+			params.push(...values);
+			return this;
+		},
+		build() {
+			return {
+				query: sql.join(""),
+				params
+			};
+		}
 	};
 };
-const wrapInConnectionClosure = async (connection, handle) => {
-	try {
-		return await handle();
-	} finally {
-		await connection.close();
-	}
-};
-const transactionFactoryWithNewConnection = (connect) => ({
-	transaction: (options) => {
-		const connection = connect();
-		const transaction = connection.transaction(options);
+
+//#endregion
+//#region src/core/sql/tokens/sqlToken.ts
+const SQLToken = (sqlTokenType, map) => {
+	const factory = (input) => {
+		let props;
+		if (map !== void 0) props = map(input);
+		else if (input === void 0 || input === null) props = {};
+		else if (typeof input === "object" && !Array.isArray(input)) props = input;
+		else throw new Error(`Cannot create SQLToken of type ${sqlTokenType} with input: ${input}`);
 		return {
-			...transaction,
-			commit: () => wrapInConnectionClosure(connection, () => transaction.commit()),
-			rollback: () => wrapInConnectionClosure(connection, () => transaction.rollback())
+			sqlTokenType,
+			[sqlTokenType]: true,
+			...props
 		};
-	},
-	withTransaction: (handle, options) => {
-		const connection = connect();
-		const withTx = connection.withTransaction;
-		return wrapInConnectionClosure(connection, () => withTx(handle, options));
-	}
+	};
+	const check = (token) => SQLToken.check(token) && token.sqlTokenType === sqlTokenType;
+	return {
+		from: factory,
+		check,
+		type: sqlTokenType
+	};
+};
+SQLToken.check = (token) => token !== null && typeof token === "object" && "sqlTokenType" in token;
+const SQLIdentifier = SQLToken("SQL_IDENTIFIER", (value) => ({ value }));
+const SQLPlain = SQLToken("SQL_RAW", (value) => ({ value }));
+const SQLLiteral = SQLToken("SQL_LITERAL", (value) => ({ value }));
+const SQLArray = SQLToken("SQL_ARRAY", (input) => {
+	if (Array.isArray(input)) return { value: input };
+	return input.mode !== void 0 ? {
+		value: input.value,
+		mode: input.mode
+	} : { value: input.value };
 });
-const transactionFactoryWithAmbientConnection = (connect) => ({
-	transaction: (options) => {
-		const transaction = connect().transaction(options);
+const SQLIn = SQLToken("SQL_IN", ({ column, values, mode }) => mode !== void 0 ? {
+	column: SQLIdentifier.from(column),
+	values: SQLArray.from(values),
+	mode
+} : {
+	column: SQLIdentifier.from(column),
+	values: SQLArray.from(values)
+});
+
+//#endregion
+//#region src/core/sql/tokens/columnTokens.ts
+const ColumnTypeToken = (sqlTokenType, jsTypeName, map) => {
+	const factory = (input) => {
+		let props;
+		if (map !== void 0) props = map(input);
+		else if (input === void 0 || input === null) props = {};
+		else if (typeof input === "object" && !Array.isArray(input)) props = input;
+		else throw new Error(`Cannot create SQLToken of type ${sqlTokenType} with input: ${input}`);
 		return {
-			...transaction,
-			commit: () => transaction.commit(),
-			rollback: () => transaction.rollback()
+			sqlTokenType,
+			[sqlTokenType]: true,
+			jsTypeName,
+			...props
+		};
+	};
+	const check = (token) => SQLToken.check(token) && token.sqlTokenType === sqlTokenType;
+	return {
+		from: factory,
+		check,
+		type: sqlTokenType
+	};
+};
+const SerialToken = ColumnTypeToken("SQL_COLUMN_SERIAL", "value_type:js:number");
+const BigSerialToken = ColumnTypeToken("SQL_COLUMN_BIGSERIAL", "value_type:js:bigint");
+const IntegerToken = ColumnTypeToken("SQL_COLUMN_INTEGER", "value_type:js:number");
+const BigIntegerToken = ColumnTypeToken("SQL_COLUMN_BIGINT", "value_type:js:bigint");
+const JSONBToken = {
+	type: "SQL_COLUMN_JSONB",
+	from: () => {
+		return {
+			sqlTokenType: "SQL_COLUMN_JSONB",
+			["SQL_COLUMN_JSONB"]: true
 		};
 	},
-	withTransaction: (handle, options) => {
-		const withTx = connect().withTransaction;
-		return withTx(handle, options);
+	check: (token) => SQLToken.check(token) && token.sqlTokenType === "SQL_COLUMN_JSONB"
+};
+const TimestampToken = ColumnTypeToken("SQL_COLUMN_TIMESTAMP", "value_type:js:date");
+const TimestamptzToken = ColumnTypeToken("SQL_COLUMN_TIMESTAMPTZ", "value_type:js:date");
+const VarcharToken = ColumnTypeToken("SQL_COLUMN_VARCHAR", "value_type:js:string", (length) => ({
+	length: length ?? "max",
+	jsTypeName: "value_type:js:string"
+}));
+const AutoIncrementSQLColumnToken = ColumnTypeToken("SQL_COLUMN_AUTO_INCREMENT", "value_type:js:bigint");
+const SQLColumnTypeTokens = {
+	AutoIncrement: AutoIncrementSQLColumnToken,
+	BigInteger: BigIntegerToken,
+	BigSerial: BigSerialToken,
+	Integer: IntegerToken,
+	JSONB: JSONBToken,
+	Serial: SerialToken,
+	Timestamp: TimestampToken,
+	Timestamptz: TimestamptzToken,
+	Varchar: VarcharToken
+};
+const SQLColumnTypeTokensFactory = {
+	AutoIncrement: AutoIncrementSQLColumnToken.from,
+	BigInteger: BigIntegerToken.from(),
+	BigSerial: BigSerialToken.from(),
+	Integer: IntegerToken.from(),
+	JSONB: JSONBToken.from,
+	Serial: SerialToken.from(),
+	Timestamp: TimestampToken.from(),
+	Timestamptz: TimestamptzToken.from(),
+	Varchar: VarcharToken.from
+};
+const SQLColumnToken = SQLToken("SQL_COLUMN");
+
+//#endregion
+//#region src/core/sql/processors/sqlProcessor.ts
+const SQLProcessor = (options) => options;
+
+//#endregion
+//#region src/core/sql/processors/defaultProcessors.ts
+const ExpandArrayProcessor = SQLProcessor({
+	canHandle: "SQL_ARRAY",
+	handle: (token, { builder, serializer, mapper }) => {
+		if (token.value.length === 0) throw new Error("Empty arrays are not supported. If you're using it with SELECT IN statement Use SQL.in(column, array) helper instead.");
+		builder.addParams(mapper.mapValue(token.value, serializer));
 	}
 });
-const transactionFactoryWithAsyncAmbientConnection = (driverType, connect, close) => {
-	close ??= () => Promise.resolve();
+const ExpandSQLInProcessor = SQLProcessor({
+	canHandle: "SQL_IN",
+	handle: (token, context) => {
+		const { builder, mapper, processorsRegistry, serializer } = context;
+		const { values: inValues, column } = token;
+		if (inValues.value.length === 0) {
+			builder.addParam(mapper.mapValue(false, serializer));
+			return;
+		}
+		builder.addSQL(mapper.mapValue(column.value, serializer));
+		builder.addSQL(` IN (`);
+		const arrayProcessor = processorsRegistry.get(SQLArray.type);
+		if (!arrayProcessor) throw new Error("No sql processor registered for an array. Cannot expand IN statement");
+		arrayProcessor.handle(inValues, {
+			builder,
+			mapper,
+			processorsRegistry,
+			serializer
+		});
+		builder.addSQL(`)`);
+	}
+});
+const FormatIdentifierProcessor = SQLProcessor({
+	canHandle: "SQL_IDENTIFIER",
+	handle: (token, { builder, mapper, serializer }) => {
+		builder.addSQL(mapper.mapValue(token, serializer));
+	}
+});
+const MapLiteralProcessor = SQLProcessor({
+	canHandle: "SQL_LITERAL",
+	handle: (token, { builder, mapper, serializer }) => builder.addParam(mapper.mapValue(token.value, serializer))
+});
+
+//#endregion
+//#region src/core/sql/processors/sqlProcessorRegistry.ts
+const SQLProcessorsRegistry = (options) => {
+	const processors = options ? new Map(options.from.all()) : /* @__PURE__ */ new Map();
+	function register(...args) {
+		if (args.length === 1 && typeof args[0] === "object" && !Array.isArray(args[0])) Object.entries(args[0]).forEach(([_, processor]) => {
+			processors.set(processor.canHandle, processor);
+		});
+		else args.forEach((p) => processors.set(p.canHandle, p));
+		return registry;
+	}
+	const registry = {
+		register,
+		get: (tokenType) => {
+			return processors.get(tokenType) ?? null;
+		},
+		all: () => processors
+	};
+	return registry;
+};
+
+//#endregion
+//#region src/core/sql/processors/columnProcessors.ts
+const mapDefaultSQLColumnProcessors = (mapColumnType) => ({
+	AutoIncrement: SQLProcessor({
+		canHandle: "SQL_COLUMN_AUTO_INCREMENT",
+		handle: (token, context) => {
+			mapColumnType(token, context);
+		}
+	}),
+	BigInteger: SQLProcessor({
+		canHandle: "SQL_COLUMN_BIGINT",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	BigSerial: SQLProcessor({
+		canHandle: "SQL_COLUMN_BIGSERIAL",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	Serial: SQLProcessor({
+		canHandle: "SQL_COLUMN_SERIAL",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	Integer: SQLProcessor({
+		canHandle: "SQL_COLUMN_INTEGER",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	JSONB: SQLProcessor({
+		canHandle: "SQL_COLUMN_JSONB",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	Timestamp: SQLProcessor({
+		canHandle: "SQL_COLUMN_TIMESTAMP",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	Timestamptz: SQLProcessor({
+		canHandle: "SQL_COLUMN_TIMESTAMPTZ",
+		handle: (token, context) => mapColumnType(token, context)
+	}),
+	Varchar: SQLProcessor({
+		canHandle: "SQL_COLUMN_VARCHAR",
+		handle: (token, context) => mapColumnType(token, context)
+	})
+});
+
+//#endregion
+//#region src/core/sql/processors/index.ts
+const defaultProcessorsRegistry = globalThis.defaultProcessorsRegistry = globalThis.defaultProcessorsRegistry ?? SQLProcessorsRegistry().register(FormatIdentifierProcessor, MapLiteralProcessor, ExpandArrayProcessor, ExpandSQLInProcessor);
+
+//#endregion
+//#region src/core/sql/tokenizedSQL/tokenizedSQL.ts
+const TokenizedSQLBuilder = () => {
+	const sqlChunks = [];
+	const sqlTokens = [];
 	return {
-		transaction: (options) => {
-			let conn = null;
-			let innerTx = null;
-			let connectingPromise = null;
-			const ensureConnection = async () => {
-				if (conn) return innerTx;
-				if (!connectingPromise) connectingPromise = (async () => {
-					conn = await connect();
-					innerTx = conn.transaction(options);
-				})();
-				await connectingPromise;
-				return innerTx;
-			};
-			return {
-				driverType,
-				get connection() {
-					if (!conn) throw new Error("Transaction not started - call begin() first");
-					return conn;
-				},
-				execute: {
-					query: async (sql, queryOptions) => {
-						return (await ensureConnection()).execute.query(sql, queryOptions);
-					},
-					batchQuery: async (sqls, queryOptions) => {
-						return (await ensureConnection()).execute.batchQuery(sqls, queryOptions);
-					},
-					command: async (sql, commandOptions) => {
-						return (await ensureConnection()).execute.command(sql, commandOptions);
-					},
-					batchCommand: async (sqls, commandOptions) => {
-						return (await ensureConnection()).execute.batchCommand(sqls, commandOptions);
-					}
-				},
-				begin: async () => {
-					return (await ensureConnection()).begin();
-				},
-				commit: async () => {
-					if (!innerTx) throw new Error("Transaction not started");
-					try {
-						return await innerTx.commit();
-					} finally {
-						if (conn) await close(conn);
-					}
-				},
-				rollback: async (error) => {
-					if (!innerTx) {
-						if (conn) await close(conn);
-						return;
-					}
-					try {
-						return await innerTx.rollback(error);
-					} finally {
-						if (conn) await close(conn);
-					}
-				},
-				_transactionOptions: void 0
-			};
+		addSQL(str) {
+			sqlChunks.push(str);
 		},
-		withTransaction: async (handle, options) => {
-			const conn = await connect();
-			try {
-				const withTx = conn.withTransaction;
-				return await withTx(handle, options);
-			} finally {
-				await close(conn);
-			}
+		addSQLs(str) {
+			sqlChunks.push(...str);
+		},
+		addToken(value) {
+			sqlTokens.push(value);
+		},
+		addTokens(vals) {
+			sqlTokens.push(...vals);
+		},
+		build() {
+			return sqlChunks.length > 0 ? {
+				__brand: "tokenized-sql",
+				sqlChunks,
+				sqlTokens
+			} : TokenizedSQL.empty;
 		}
 	};
 };
+const TokenizedSQL = (strings, values) => {
+	const builder = TokenizedSQLBuilder();
+	for (let i = 0; i < strings.length; i++) {
+		if (strings[i] !== "") builder.addSQL(strings[i]);
+		if (i >= values.length) break;
+		const value = values[i];
+		if (isTokenizedSQL(value)) {
+			builder.addSQLs(value.sqlChunks);
+			builder.addTokens(value.sqlTokens);
+		} else if (SQLPlain.check(value)) builder.addSQL(value.value);
+		else {
+			builder.addSQL(TokenizedSQL.paramPlaceholder);
+			builder.addToken(SQLToken.check(value) ? value : Array.isArray(value) ? SQLArray.from(value) : SQLLiteral.from(value));
+		}
+	}
+	return builder.build();
+};
+const isTokenizedSQL = (value) => {
+	return value !== null && typeof value === "object" && "__brand" in value && value.__brand === "tokenized-sql";
+};
+TokenizedSQL.paramPlaceholder = `__P__`;
+TokenizedSQL.empty = {
+	__brand: "tokenized-sql",
+	sqlChunks: [""],
+	sqlTokens: []
+};
+
+//#endregion
+//#region src/core/sql/sql.ts
+const createSQL = (strings, ...values) => {
+	return TokenizedSQL(strings, values);
+};
+/**
+* Creates SQL by interpolating values directly into the statement.
+*
+* Prefer {@link SQL} for query execution. `RawSQL` is for trusted SQL text that
+* is already safe to inline.
+*/
+function RawSQL(strings, ...values) {
+	let result = "";
+	for (let i = 0; i < strings.length; i++) {
+		result += strings[i];
+		if (i < values.length) result += String(values[i]);
+	}
+	return {
+		__brand: "tokenized-sql",
+		sqlChunks: [result],
+		sqlTokens: []
+	};
+}
+/** Returns true when the value is a tokenized SQL statement. */
+const isSQL = (value) => {
+	if (value === void 0 || value === null) return false;
+	return isTokenizedSQL(value);
+};
+const emptySQL = {
+	__brand: "tokenized-sql",
+	sqlChunks: [""],
+	sqlTokens: []
+};
+const mergeSQL = (sqls, separator = " ") => {
+	const parametrized = sqls.filter((sql) => !isEmpty(sql)).map((sql) => sql);
+	const params = parametrized.flatMap((p) => p.sqlTokens);
+	const sqlChunks = parametrized.flatMap((p, i) => i == parametrized.length - 1 || separator === "" ? p.sqlChunks : [...p.sqlChunks, separator]);
+	return sqlChunks.length > 0 ? {
+		__brand: "tokenized-sql",
+		sqlChunks,
+		sqlTokens: params
+	} : TokenizedSQL.empty;
+};
+const concatSQL = (...sqls) => mergeSQL(sqls, "");
+const literal = (value) => SQLPlain.from(`'${value.replace(/'/g, "''")}'`);
+const isEmpty = (sql) => {
+	if (isTokenizedSQL(sql)) {
+		const parametrized = sql;
+		return parametrized.sqlChunks.every((chunk) => chunk.trim() === "") && parametrized.sqlTokens.length === 0;
+	}
+	return false;
+};
+const columnFactory = SQLColumnToken.from;
+columnFactory.type = SQLColumnTypeTokensFactory;
+const schemaColumnFactory = ((name, type, options) => columnSchemaComponent({
+	columnName: name,
+	type,
+	...options
+}));
+const SQL = Object.assign(createSQL, {
+	EMPTY: emptySQL,
+	concat: concatSQL,
+	merge: mergeSQL,
+	format: (sql, formatter, options) => formatSQL(sql, formatter, options?.serializer ?? JSONSerializer, options),
+	describe: (sql, formatter, options) => describeSQL(sql, formatter, options?.serializer ?? JSONSerializer, options),
+	in: (column, values, options) => options?.mode ? SQLIn.from({
+		column,
+		values,
+		mode: options.mode
+	}) : SQLIn.from({
+		column,
+		values
+	}),
+	array: (values, options) => SQLArray.from(options?.mode ? {
+		value: values,
+		mode: options.mode
+	} : values),
+	identifier: SQLIdentifier.from,
+	plain: SQLPlain.from,
+	literal,
+	check: {
+		isSQL,
+		isTokenizedSQL: (value) => isTokenizedSQL(value),
+		isEmpty,
+		isIdentifier: SQLIdentifier.check,
+		isPlain: SQLPlain.check,
+		isSQLIn: SQLIn.check
+	},
+	column: columnFactory,
+	columnN: Object.assign(schemaColumnFactory, { type: SQLColumnTypeTokensFactory })
+});
+
+//#endregion
+//#region src/core/sql/valueMappers/reservedSqlWords.ts
+const ansiSqlReservedMap = {
+	ALL: true,
+	AND: true,
+	ANY: true,
+	ARRAY: true,
+	AS: true,
+	ASC: true,
+	AUTHORIZATION: true,
+	BETWEEN: true,
+	BINARY: true,
+	BOTH: true,
+	CASE: true,
+	CAST: true,
+	CHECK: true,
+	COLLATE: true,
+	COLUMN: true,
+	CONSTRAINT: true,
+	CREATE: true,
+	CROSS: true,
+	CURRENT_DATE: true,
+	CURRENT_TIME: true,
+	CURRENT_TIMESTAMP: true,
+	CURRENT_USER: true,
+	DEFAULT: true,
+	DEFERRABLE: true,
+	DESC: true,
+	DISTINCT: true,
+	DO: true,
+	ELSE: true,
+	END: true,
+	EXCEPT: true,
+	FALSE: true,
+	FOR: true,
+	FOREIGN: true,
+	FROM: true,
+	FULL: true,
+	GRANT: true,
+	GROUP: true,
+	HAVING: true,
+	IN: true,
+	INITIALLY: true,
+	INNER: true,
+	INTERSECT: true,
+	INTO: true,
+	IS: true,
+	JOIN: true,
+	LEADING: true,
+	LEFT: true,
+	LIKE: true,
+	LOCALTIME: true,
+	LOCALTIMESTAMP: true,
+	NATURAL: true,
+	NEW: true,
+	NOT: true,
+	NULL: true,
+	NULLS: true,
+	OLD: true,
+	ON: true,
+	ONLY: true,
+	OPEN: true,
+	OR: true,
+	ORDER: true,
+	OUTER: true,
+	OVERLAPS: true,
+	PARTITION: true,
+	PLACING: true,
+	PRIMARY: true,
+	REFERENCES: true,
+	RIGHT: true,
+	SELECT: true,
+	SESSION_USER: true,
+	SIMILAR: true,
+	SOME: true,
+	TABLE: true,
+	THEN: true,
+	TO: true,
+	TRAILING: true,
+	TRUE: true,
+	UNION: true,
+	UNIQUE: true,
+	USER: true,
+	USING: true,
+	WHEN: true,
+	WHERE: true,
+	WITH: true,
+	WITHOUT: true,
+	ADD: true,
+	ALTER: true,
+	ARE: true,
+	AT: true,
+	BEGIN: true,
+	BY: true,
+	CASCADE: true,
+	CLOSE: true,
+	COMMIT: true,
+	CONNECT: true,
+	CONTINUE: true,
+	CORRESPONDING: true,
+	CURSOR: true,
+	DEALLOCATE: true,
+	DECLARE: true,
+	DELETE: true,
+	DESCRIBE: true,
+	DISCONNECT: true,
+	DROP: true,
+	ESCAPE: true,
+	EXECUTE: true,
+	EXISTS: true,
+	FETCH: true,
+	FIRST: true,
+	FLOAT: true,
+	GET: true,
+	GLOBAL: true,
+	GO: true,
+	GOTO: true,
+	HOUR: true,
+	IMMEDIATE: true,
+	INDICATOR: true,
+	INPUT: true,
+	INSERT: true,
+	INT: true,
+	INTEGER: true,
+	INTERVAL: true,
+	LANGUAGE: true,
+	LAST: true,
+	LOCAL: true,
+	MATCH: true,
+	MINUTE: true,
+	MODULE: true,
+	MONTH: true,
+	NATIONAL: true,
+	NEXT: true,
+	NO: true,
+	OF: true,
+	OUTPUT: true,
+	PARTIAL: true,
+	PREPARE: true,
+	PRESERVE: true,
+	PRIOR: true,
+	PRIVILEGES: true,
+	PROCEDURE: true,
+	PUBLIC: true,
+	READ: true,
+	REAL: true,
+	RESTRICT: true,
+	REVOKE: true,
+	ROLLBACK: true,
+	ROWS: true,
+	SCHEMA: true,
+	SCROLL: true,
+	SECOND: true,
+	SECTION: true,
+	SET: true,
+	SIZE: true,
+	SMALLINT: true,
+	SQL: true,
+	SQLCODE: true,
+	SQLERROR: true,
+	SQLSTATE: true,
+	TEMPORARY: true,
+	TIMEZONE_HOUR: true,
+	TIMEZONE_MINUTE: true,
+	TRANSACTION: true,
+	TRANSLATE: true,
+	TRANSLATION: true,
+	UNKNOWN: true,
+	UPDATE: true,
+	VALUE: true,
+	VALUES: true,
+	VARCHAR: true,
+	VARYING: true,
+	VIEW: true,
+	WHENEVER: true,
+	WORK: true,
+	WRITE: true,
+	YEAR: true,
+	ZONE: true
+};
 
 //#endregion
-//#region src/core/connections/connection.ts
-const createAmbientConnection = (options) => {
-	const { driverType, client, executor, initTransaction, serializer } = options;
-	const clientPromise = Promise.resolve(client);
-	const closePromise = Promise.resolve();
-	const open = () => clientPromise;
-	const close = () => closePromise;
-	const typedConnection = {
-		driverType,
-		open,
-		close,
-		...transactionFactoryWithDbClient(open, initTransaction(() => typedConnection)),
-		execute: sqlExecutor(executor({ serializer }), { connect: open }),
-		_transactionType: void 0
-	};
-	return typedConnection;
-};
-const createSingletonConnection = (options) => {
-	const { driverType, connect, close, initTransaction, executor, serializer } = options;
-	let client = null;
-	let connectPromise = null;
-	const getClient = async () => {
-		if (client) return client;
-		if (!connectPromise) connectPromise = connect().then((c) => {
-			client = c;
-			return c;
-		});
-		return connectPromise;
-	};
-	const typedConnection = {
-		driverType,
-		open: getClient,
-		close: () => client ? close(client) : Promise.resolve(),
-		...transactionFactoryWithDbClient(getClient, initTransaction(() => typedConnection)),
-		execute: sqlExecutor(executor({ serializer }), { connect: getClient }),
-		_transactionType: void 0
-	};
-	return typedConnection;
+//#region src/core/sql/valueMappers/sqlValueMapper.ts
+const ANSISQLParamPlaceholder = "?";
+const ANSISQLIdentifierQuote = "\"";
+const mapANSISQLParamPlaceholder = () => "?";
+const isReserved = (value, reserved) => !!reserved[value.toUpperCase()];
+const mapSQLIdentifier = (value, options) => {
+	if (value === void 0 || value === null) throw new Error("SQL identifier cannot be null or undefined");
+	const ident = value.toString().slice(0);
+	const quoteSign = options?.quote ?? "\"";
+	if (/^[a-z_][a-z0-9_$]*$/.test(ident) && !isReserved(ident, options?.reservedWords ?? ansiSqlReservedMap)) return ident;
+	let quoted = quoteSign;
+	for (let i = 0; i < ident.length; i++) {
+		const c = ident[i];
+		quoted += c === quoteSign ? c + c : c;
+	}
+	quoted += quoteSign;
+	return quoted;
 };
-const createTransientConnection = (options) => {
-	const { driverType, open, close, initTransaction, executor, serializer } = options;
-	const typedConnection = {
-		driverType,
-		open,
-		close,
-		...transactionFactoryWithDbClient(open, initTransaction(() => typedConnection)),
-		execute: sqlExecutor(executor({ serializer }), { connect: open }),
-		_transactionType: void 0
-	};
-	return typedConnection;
+const DefaultMapSQLParamValueOptions = {
+	mapPlaceholder: mapANSISQLParamPlaceholder,
+	mapIdentifier: mapSQLIdentifier
 };
-const createConnection = (options) => {
-	const { driverType, connect, close, initTransaction, executor, serializer } = options;
-	let client = null;
-	let connectPromise = null;
-	const getClient = async () => {
-		if (client) return client;
-		if (!connectPromise) connectPromise = connect().then((c) => {
-			client = c;
-			return c;
-		});
-		return connectPromise;
+const SQLValueMapper = (options) => {
+	const mapSQLParamValueOptions = {
+		...DefaultMapSQLParamValueOptions,
+		...options ?? {}
 	};
-	const typedConnection = {
-		driverType,
-		open: getClient,
-		close: () => client ? close(client) : Promise.resolve(),
-		...transactionFactoryWithDbClient(getClient, initTransaction(() => typedConnection)),
-		execute: sqlExecutor(executor({ serializer }), { connect: getClient }),
-		_transactionType: void 0
+	return {
+		mapValue: (value, serializer, mapOptions) => mapSQLParamValue(value, serializer, {
+			...mapSQLParamValueOptions,
+			...mapOptions
+		}),
+		mapPlaceholder: mapSQLParamValueOptions.mapPlaceholder,
+		mapIdentifier: mapSQLParamValueOptions.mapIdentifier
 	};
-	return typedConnection;
 };
+function mapSQLParamValue(value, serializer, options) {
+	if (value === null || value === void 0) return null;
+	else if (typeof value === "number") return value;
+	else if (typeof value === "string") return value;
+	else if (Array.isArray(value)) {
+		const mapValue = options?.mapValue ?? mapSQLParamValue;
+		return options?.mapArray ? options.mapArray(value, mapValue) : value.map((item) => mapValue(item, serializer, options));
+	} else if (typeof value === "boolean") return options?.mapBoolean ? options.mapBoolean(value) : value;
+	else if (typeof value === "bigint") return options?.mapBigInt ? options.mapBigInt(value) : value.toString();
+	else if (value instanceof Date) return options?.mapDate ? options.mapDate(value) : value.toISOString();
+	else if (SQL.check.isIdentifier(value)) return (options?.mapIdentifier ?? mapSQLIdentifier)(value.value);
+	else if (typeof value === "object") return options?.mapObject ? options.mapObject(value) : serializer.serialize(value);
+	else return serializer.serialize(value);
+}
 
 //#endregion
-//#region src/core/taskProcessing/taskProcessor.ts
-var TaskProcessor = class {
-	queue = [];
-	isProcessing = false;
-	activeTasks = 0;
-	activeGroups = /* @__PURE__ */ new Set();
-	options;
-	stopped = false;
-	constructor(options) {
-		this.options = options;
-	}
-	enqueue(task, options) {
-		if (this.stopped) return Promise.reject(new DumboError("TaskProcessor has been stopped"));
-		if (this.queue.length >= this.options.maxQueueSize) return Promise.reject(new TransientDatabaseError("Too many pending connections. Please try again later."));
-		return this.schedule(task, options);
-	}
-	waitForEndOfProcessing() {
-		return this.schedule(({ ack }) => Promise.resolve(ack()));
-	}
-	async stop(options) {
-		if (this.stopped) return;
-		this.stopped = true;
-		this.queue.length = 0;
-		this.activeGroups.clear();
-		if (!options?.force) await this.waitForEndOfProcessing();
-	}
-	schedule(task, options) {
-		return promiseWithDeadline((resolve, reject) => {
-			const taskWithContext = () => {
-				return new Promise((resolveTask, failTask) => {
-					task({ ack: resolveTask }).then(resolve).catch((err) => {
-						failTask(err);
-						reject(err);
-					});
-				});
-			};
-			this.queue.push({
-				task: taskWithContext,
-				options
-			});
-			if (!this.isProcessing) this.ensureProcessing();
-		}, { deadline: this.options.maxTaskIdleTime });
-	}
-	ensureProcessing() {
-		if (this.isProcessing) return;
-		this.isProcessing = true;
-		this.processQueue();
-	}
-	processQueue() {
-		try {
-			while (this.activeTasks < this.options.maxActiveTasks && this.queue.length > 0) {
-				const item = this.takeFirstAvailableItem();
-				if (item === null) return;
-				const groupId = item.options?.taskGroupId;
-				if (groupId) this.activeGroups.add(groupId);
-				this.activeTasks++;
-				this.executeItem(item);
-			}
-		} catch (error) {
-			console.error(error);
-			throw error;
-		} finally {
-			this.isProcessing = false;
-			if (this.hasItemsToProcess() && this.activeTasks < this.options.maxActiveTasks) this.ensureProcessing();
+//#region src/core/sql/formatters/sqlFormatter.ts
+const SQLFormatter = ({ format, describe, valueMapper: valueMapperOptions, processorsRegistry }) => {
+	const valueMapper = SQLValueMapper(valueMapperOptions);
+	const options = {
+		builder: ParametrizedSQLBuilder({ mapParamPlaceholder: valueMapper.mapPlaceholder }),
+		mapper: valueMapper,
+		processorsRegistry: processorsRegistry ?? defaultProcessorsRegistry
+	};
+	const resultFormatter = {
+		format: format ?? ((sql, methodOptions) => formatSQL(sql, resultFormatter, methodOptions?.serializer ?? JSONSerializer, {
+			...options,
+			...methodOptions ?? {}
+		})),
+		describe: describe ?? ((sql, methodOptions) => describeSQL(sql, resultFormatter, methodOptions?.serializer ?? JSONSerializer, {
+			...options,
+			...methodOptions ?? {}
+		})),
+		valueMapper
+	};
+	return resultFormatter;
+};
+const dumboSQLFormatters = globalThis.dumboSQLFormatters = globalThis.dumboSQLFormatters ?? {};
+const registerFormatter = (dialect, formatter) => {
+	dumboSQLFormatters[dialect] = formatter;
+};
+const getFormatter = (dialect) => {
+	const formatterKey = dialect;
+	if (!dumboSQLFormatters[formatterKey]) throw new Error(`No SQL formatter registered for dialect: ${dialect}`);
+	return dumboSQLFormatters[formatterKey];
+};
+function formatSQL(sql, formatter, serializer, context) {
+	const mapper = context?.mapper == void 0 ? formatter.valueMapper : {
+		...formatter.valueMapper,
+		...context.mapper
+	};
+	const processorsRegistry = context?.processorsRegistry ?? defaultProcessorsRegistry;
+	const merged = Array.isArray(sql) ? SQL.merge(sql, "\n") : sql;
+	if (!isTokenizedSQL(merged)) throw new Error("Expected TokenizedSQL, got string-based SQL");
+	const builder = ParametrizedSQLBuilder({ mapParamPlaceholder: mapper.mapPlaceholder });
+	let paramIndex = 0;
+	for (let i = 0; i < merged.sqlChunks.length; i++) {
+		const sqlChunk = merged.sqlChunks[i];
+		if (sqlChunk !== TokenizedSQL.paramPlaceholder) {
+			builder.addSQL(sqlChunk);
+			continue;
 		}
+		const token = merged.sqlTokens[paramIndex++];
+		const processor = processorsRegistry.get(token.sqlTokenType);
+		if (!processor) throw new Error(`No SQL processor registered for token type: ${token.sqlTokenType}`);
+		processor.handle(token, {
+			builder,
+			processorsRegistry,
+			serializer,
+			mapper
+		});
 	}
-	async executeItem({ task, options }) {
-		try {
-			await task();
-		} finally {
-			this.activeTasks--;
-			if (options && options.taskGroupId) this.activeGroups.delete(options.taskGroupId);
-			this.ensureProcessing();
-		}
+	return builder.build();
+}
+const describeSQL = (sql, formatter, serializer, options) => formatSQL(sql, formatter, serializer, {
+	...options ?? {},
+	mapper: { mapPlaceholder: (_, value) => serializer.serialize(value) }
+}).query;
+
+//#endregion
+//#region src/core/tracing/printing/color.ts
+let enableColors = true;
+const color = {
+	set level(value) {
+		enableColors = value === 1;
+	},
+	hex: (value) => (text) => enableColors ? ansis.hex(value)(text) : text,
+	red: (value) => enableColors ? ansis.red(value) : value,
+	green: (value) => enableColors ? ansis.green(value) : value,
+	blue: (value) => enableColors ? ansis.blue(value) : value,
+	cyan: (value) => enableColors ? ansis.cyan(value) : value,
+	yellow: (value) => enableColors ? ansis.yellow(value) : value
+};
+
+//#endregion
+//#region src/core/tracing/printing/pretty.ts
+const TWO_SPACES = "  ";
+const COLOR_STRING = color.hex("#98c379");
+const COLOR_KEY = color.hex("#61afef");
+const COLOR_NUMBER_OR_DATE = color.hex("#d19a66");
+const COLOR_BOOLEAN = color.hex("#c678dd");
+const COLOR_NULL_OR_UNDEFINED = color.hex("#c678dd");
+const COLOR_BRACKETS = color.hex("#abb2bf");
+const processString = (str, indent, handleMultiline) => {
+	if (handleMultiline && str.includes("\n")) {
+		const indentedLines = str.split("\n").map((line) => indent + TWO_SPACES + COLOR_STRING(line));
+		return COLOR_STRING("\"") + "\n" + indentedLines.join("\n") + "\n" + indent + COLOR_STRING("\"");
 	}
-	takeFirstAvailableItem = () => {
-		const taskIndex = this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId));
-		if (taskIndex === -1) return null;
-		const [item] = this.queue.splice(taskIndex, 1);
-		return item ?? null;
-	};
-	hasItemsToProcess = () => this.queue.findIndex((item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId)) !== -1;
+	return COLOR_STRING(`"${str}"`);
 };
-const DEFAULT_PROMISE_DEADLINE = 2147483647;
-const promiseWithDeadline = (executor, options) => {
-	return new Promise((resolve, reject) => {
-		let taskStarted = false;
-		let timeoutId = null;
-		const deadline = options.deadline ?? DEFAULT_PROMISE_DEADLINE;
-		timeoutId = setTimeout(() => {
-			if (!taskStarted) reject(/* @__PURE__ */ new Error("Task was not started within the maximum waiting time"));
-		}, deadline);
-		timeoutId.unref();
-		executor((value) => {
-			taskStarted = true;
-			if (timeoutId) clearTimeout(timeoutId);
-			timeoutId = null;
-			resolve(value);
-		}, (reason) => {
-			if (timeoutId) clearTimeout(timeoutId);
-			timeoutId = null;
-			reject(reason);
+const shouldPrint = (obj) => typeof obj !== "function" && typeof obj !== "symbol";
+const formatJson = (obj, indentLevel = 0, handleMultiline = false) => {
+	const indent = TWO_SPACES.repeat(indentLevel);
+	if (obj === null) return COLOR_NULL_OR_UNDEFINED("null");
+	if (obj === void 0) return COLOR_NULL_OR_UNDEFINED("undefined");
+	if (typeof obj === "string") return processString(obj, indent, handleMultiline);
+	if (typeof obj === "number" || typeof obj === "bigint" || obj instanceof Date) return COLOR_NUMBER_OR_DATE(String(obj));
+	if (typeof obj === "boolean") return COLOR_BOOLEAN(String(obj));
+	if (obj instanceof Error) {
+		const errorObj = {};
+		Object.getOwnPropertyNames(obj).forEach((key) => {
+			errorObj[key] = obj[key];
 		});
-	});
+		return formatJson(errorObj, indentLevel, handleMultiline);
+	}
+	if (obj instanceof Promise) return COLOR_STRING("Promise {pending}");
+	if (Array.isArray(obj)) {
+		const arrayItems = obj.map((item) => formatJson(item, indentLevel + 1, handleMultiline));
+		return `${COLOR_BRACKETS("[")}\n${indent}  ${arrayItems.join(`,\n${indent}  `)}\n${indent}${COLOR_BRACKETS("]")}`;
+	}
+	const entries = Object.entries(obj).filter(([_, value]) => shouldPrint(value)).map(([key, value]) => `${COLOR_KEY(`"${key}"`)}: ${formatJson(value, indentLevel + 1, handleMultiline)}`);
+	return `${COLOR_BRACKETS("{")}\n${indent}  ${entries.join(`,\n${indent}  `)}\n${indent}${COLOR_BRACKETS("}")}`;
 };
+const prettyJson = (obj, options) => formatJson(obj, 0, options?.handleMultiline);
 
 //#endregion
-//#region src/core/taskProcessing/executionGuards.ts
-const guardBoundedAccess = (getResource, options) => {
-	let isStopped = false;
-	const taskProcessor = new TaskProcessor({
-		maxActiveTasks: options.maxResources,
-		maxQueueSize: options.maxQueueSize ?? 1e3
-	});
-	const resourcePool = [];
-	const allResources = /* @__PURE__ */ new Set();
-	const ackCallbacks = /* @__PURE__ */ new Map();
-	const acquire = async () => taskProcessor.enqueue(async ({ ack }) => {
-		try {
-			let resource;
-			if (options.reuseResources) resource = resourcePool.pop();
-			if (!resource) {
-				resource = await getResource();
-				allResources.add(resource);
-			}
-			ackCallbacks.set(resource, ack);
-			return resource;
-		} catch (e) {
-			ack();
-			throw e;
-		}
-	});
-	const release = (resource) => {
-		const ack = ackCallbacks.get(resource);
-		if (ack) {
-			ackCallbacks.delete(resource);
-			if (options.reuseResources) resourcePool.push(resource);
-			ack();
-		}
-	};
-	const execute = async (operation) => {
-		const resource = await acquire();
-		try {
-			return await operation(resource);
-		} finally {
-			release(resource);
-		}
-	};
-	return {
-		acquire,
-		release,
-		execute,
-		waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
-		stop: async (stopOptions) => {
-			if (isStopped) return;
-			isStopped = true;
-			if (options?.closeResource) {
-				const resources = [...allResources];
-				allResources.clear();
-				resourcePool.length = 0;
-				await Promise.all(resources.map(async (resource) => await options.closeResource(resource)));
-			}
-			await taskProcessor.stop(stopOptions);
-		}
-	};
+//#region src/core/tracing/index.ts
+const tracer = () => {};
+const LogLevel = {
+	DISABLED: "DISABLED",
+	INFO: "INFO",
+	LOG: "LOG",
+	WARN: "WARN",
+	ERROR: "ERROR"
 };
-const guardInitializedOnce = (initialize, options) => {
-	let initPromise = null;
-	const taskProcessor = new TaskProcessor({
-		maxActiveTasks: 1,
-		maxQueueSize: options?.maxQueueSize ?? 1e3
-	});
-	const ensureInitialized = async (retryCount = 0) => {
-		if (initPromise !== null) return initPromise;
-		return taskProcessor.enqueue(async ({ ack }) => {
-			if (initPromise !== null) {
-				ack();
-				return initPromise;
-			}
-			try {
-				const promise = initialize();
-				initPromise = promise;
-				const result = await promise;
-				ack();
-				return result;
-			} catch (error) {
-				initPromise = null;
-				ack();
-				if (retryCount < (options?.maxRetries ?? 3)) return ensureInitialized(retryCount + 1);
-				throw error;
-			}
-		}, { taskGroupId: v7() });
-	};
-	return {
-		ensureInitialized,
-		reset: () => {
-			initPromise = null;
-		},
-		stop: (options) => taskProcessor.stop(options)
+const LogStyle = {
+	RAW: "RAW",
+	PRETTY: "PRETTY"
+};
+const getEnvVariable = (name) => {
+	try {
+		if (typeof process !== "undefined" && process.env) return process.env[name];
+		return;
+	} catch {
+		return;
+	}
+};
+const shouldLog = (logLevel) => {
+	const definedLogLevel = getEnvVariable("DUMBO_LOG_LEVEL") ?? LogLevel.ERROR;
+	if (definedLogLevel === LogLevel.ERROR && logLevel === LogLevel.ERROR) return true;
+	if (definedLogLevel === LogLevel.WARN && [LogLevel.ERROR, LogLevel.WARN].includes(logLevel)) return true;
+	if (definedLogLevel === LogLevel.LOG && [
+		LogLevel.ERROR,
+		LogLevel.WARN,
+		LogLevel.LOG
+	].includes(logLevel)) return true;
+	if (definedLogLevel === LogLevel.INFO && [
+		LogLevel.ERROR,
+		LogLevel.WARN,
+		LogLevel.LOG,
+		LogLevel.INFO
+	].includes(logLevel)) return true;
+	return false;
+};
+const nulloTraceEventRecorder = () => {};
+const getTraceEventFormatter = (logStyle, serializer = JSONSerializer) => (event) => {
+	switch (logStyle) {
+		case "RAW": return serializer.serialize(event);
+		case "PRETTY": return prettyJson(event, { handleMultiline: true });
+	}
+};
+const getTraceEventRecorder = (logLevel, logStyle) => {
+	const format = getTraceEventFormatter(logStyle);
+	switch (logLevel) {
+		case "DISABLED": return nulloTraceEventRecorder;
+		case "INFO": return (event) => console.info(format(event));
+		case "LOG": return (event) => console.log(format(event));
+		case "WARN": return (event) => console.warn(format(event));
+		case "ERROR": return (event) => console.error(format(event));
+	}
+};
+const recordTraceEvent = (logLevel, eventName, attributes) => {
+	if (!shouldLog(LogLevel.LOG)) return;
+	const event = {
+		name: eventName,
+		timestamp: (/* @__PURE__ */ new Date()).getTime(),
+		...attributes
 	};
+	getTraceEventRecorder(logLevel, getEnvVariable("DUMBO_LOG_STYLE") ?? "RAW")(event);
 };
+tracer.info = (eventName, attributes) => recordTraceEvent(LogLevel.INFO, eventName, attributes);
+tracer.warn = (eventName, attributes) => recordTraceEvent(LogLevel.WARN, eventName, attributes);
+tracer.log = (eventName, attributes) => recordTraceEvent(LogLevel.LOG, eventName, attributes);
+tracer.error = (eventName, attributes) => recordTraceEvent(LogLevel.ERROR, eventName, attributes);
 
 //#endregion
-//#region src/core/connections/pool.ts
-const wrapPooledConnection = (conn, onClose) => ({
-	...conn,
-	close: onClose
+//#region src/core/schema/sqlMigration.ts
+const sqlMigration = (name, sqls) => ({
+	name,
+	sqls
 });
-const createAmbientConnectionPool = (options) => {
-	const { driverType, connection } = options;
-	return createConnectionPool({
-		driverType,
-		getConnection: () => connection,
-		execute: connection.execute,
-		transaction: (options) => connection.transaction(options),
-		withConnection: (handle, _options) => handle(connection),
-		withTransaction: (handle, options) => {
-			const withTx = connection.withTransaction;
-			return withTx(handle, options);
-		}
-	});
-};
-const createSingletonConnectionPool = (options) => {
-	const { driverType, getConnection } = options;
-	let connectionPromise = null;
-	const getExistingOrNewConnection = () => {
-		if (!connectionPromise) connectionPromise ??= Promise.resolve(getConnection());
-		return connectionPromise;
-	};
+
+//#endregion
+//#region src/core/schema/migrators/schemaComponentMigrator.ts
+const { AutoIncrement, Varchar, Timestamp } = SQL.column.type;
+const migrationTableSQL = SQL`
+  CREATE TABLE IF NOT EXISTS dmb_migrations (
+    id ${AutoIncrement({ primaryKey: true })},
+    name ${Varchar(255)} NOT NULL UNIQUE,
+    application ${Varchar(255)} NOT NULL DEFAULT 'default',
+    sql_hash ${Varchar(64)} NOT NULL,
+    timestamp ${Timestamp} NOT NULL DEFAULT CURRENT_TIMESTAMP
+  );
+`;
+const migrationTableSchemaComponent = schemaComponent("dumbo:schema-component:migrations-table", { migrations: [sqlMigration("dumbo:migrationTable:001", [migrationTableSQL])] });
+const SchemaComponentMigrator = (component, dumbo) => {
+	const completedMigrations = [];
 	return {
-		driverType,
-		connection: () => getExistingOrNewConnection().then((conn) => wrapPooledConnection(conn, () => Promise.resolve())),
-		execute: sqlExecutorInAmbientConnection({
-			driverType,
-			connection: getExistingOrNewConnection
-		}),
-		withConnection: (handle, _options) => executeInAmbientConnection(handle, { connection: getExistingOrNewConnection }),
-		...transactionFactoryWithAsyncAmbientConnection(options.driverType, getExistingOrNewConnection, options.closeConnection),
-		close: async () => {
-			if (!connectionPromise) return;
-			await (await connectionPromise).close();
+		component,
+		run: async (options) => {
+			const pendingMigrations = component.migrations.filter((m) => !completedMigrations.includes(`${component.schemaComponentKey}:${m.name}`));
+			if (pendingMigrations.length === 0) return;
+			await runSQLMigrations(dumbo, pendingMigrations, options);
+			completedMigrations.push(...pendingMigrations.map((m) => `${component.schemaComponentKey}:${m.name}`));
 		}
 	};
 };
-const createBoundedConnectionPool = (options) => {
-	const { driverType, maxConnections } = options;
-	const guardMaxConnections = guardBoundedAccess(options.getConnection, {
-		maxResources: maxConnections,
-		reuseResources: true
-	});
-	let closed = false;
-	const executeWithPooling = async (operation) => {
-		const conn = await guardMaxConnections.acquire();
-		try {
-			return await operation(conn);
-		} finally {
-			guardMaxConnections.release(conn);
-		}
-	};
-	return {
-		driverType,
-		connection: async () => {
-			const conn = await guardMaxConnections.acquire();
-			return wrapPooledConnection(conn, () => Promise.resolve(guardMaxConnections.release(conn)));
+
+//#endregion
+//#region src/core/schema/migrators/migrator.ts
+const MIGRATIONS_LOCK_ID = 999956789;
+const defaultMigratorOptions = globalThis.defaultMigratorOptions = globalThis.defaultMigratorOptions ?? {};
+const registerDefaultMigratorOptions = (databaseType, options) => {
+	defaultMigratorOptions[databaseType] = options;
+};
+const getDefaultMigratorOptionsFromRegistry = (databaseType) => {
+	if (!defaultMigratorOptions[databaseType]) throw new Error(`No default migrator options registered for database type: ${databaseType}`);
+	return defaultMigratorOptions[databaseType];
+};
+const runSQLMigrations = (pool, migrations, partialOptions) => pool.withTransaction(async ({ execute }) => {
+	const databaseType = fromDatabaseDriverType(pool.driverType).databaseType;
+	const defaultOptions = getDefaultMigratorOptionsFromRegistry(databaseType);
+	partialOptions ??= {};
+	const options = {
+		...defaultOptions,
+		...partialOptions,
+		schema: {
+			...defaultOptions.schema,
+			...partialOptions?.schema ?? {}
 		},
-		execute: {
-			query: (sql, opts) => executeWithPooling((c) => c.execute.query(sql, opts)),
-			batchQuery: (sqls, opts) => executeWithPooling((c) => c.execute.batchQuery(sqls, opts)),
-			command: (sql, opts) => executeWithPooling((c) => c.execute.command(sql, opts)),
-			batchCommand: (sqls, opts) => executeWithPooling((c) => c.execute.batchCommand(sqls, opts))
+		lock: {
+			...defaultOptions.lock,
+			...partialOptions?.lock,
+			options: {
+				lockId: MIGRATIONS_LOCK_ID,
+				...defaultOptions.lock?.options,
+				...partialOptions?.lock?.options
+			}
 		},
-		withConnection: executeWithPooling,
-		...transactionFactoryWithAsyncAmbientConnection(driverType, guardMaxConnections.acquire, guardMaxConnections.release),
-		close: async () => {
-			if (closed) return;
-			closed = true;
-			await guardMaxConnections.stop({ force: true });
-		}
+		dryRun: defaultOptions.dryRun ?? partialOptions?.dryRun,
+		ignoreMigrationHashMismatch: defaultOptions.ignoreMigrationHashMismatch ?? partialOptions?.ignoreMigrationHashMismatch,
+		migrationTimeoutMs: defaultOptions.migrationTimeoutMs ?? partialOptions?.migrationTimeoutMs
 	};
+	const { databaseLock: _, ...rest } = options.lock ?? {};
+	const databaseLock = options.lock?.databaseLock ?? NoDatabaseLock;
+	const lockOptions = {
+		lockId: MIGRATIONS_LOCK_ID,
+		...rest
+	};
+	const coreMigrations = (options.schema?.migrationTable ?? migrationTableSchemaComponent).migrations;
+	const result = {
+		applied: [],
+		skipped: []
+	};
+	await databaseLock.withAcquire(execute, async () => {
+		for (const migration of coreMigrations) await execute.batchCommand(migration.sqls, { timeoutMs: options.migrationTimeoutMs });
+		for (const migration of migrations) if (await runSQLMigration(databaseType, execute, migration, {
+			ignoreMigrationHashMismatch: options.ignoreMigrationHashMismatch ?? false,
+			migrationTimeoutMs: options.migrationTimeoutMs
+		})) result.applied.push(migration);
+		else result.skipped.push(migration);
+	}, lockOptions);
+	return {
+		success: options.dryRun ? false : true,
+		result
+	};
+});
+const runSQLMigration = async (databaseType, execute, migration, options) => {
+	const sqls = combineMigrations(migration);
+	const sqlHash = await getMigrationHash(migration, getFormatter(databaseType));
+	try {
+		const newMigration = {
+			name: migration.name,
+			sqlHash
+		};
+		const checkResult = await ensureMigrationWasNotAppliedYet(execute, newMigration);
+		if (checkResult.exists === true) {
+			if (checkResult.hashesMatch === true) {
+				tracer.info("migration-already-applied", { migrationName: migration.name });
+				return false;
+			}
+			if (options?.ignoreMigrationHashMismatch !== true) throw new Error(`Migration hash mismatch for "${migration.name}". Aborting migration.`);
+			tracer.warn("migration-hash-mismatch", {
+				migrationName: migration.name,
+				expectedHash: sqlHash,
+				actualHash: checkResult.hashFromDB
+			});
+			await updateMigrationHash(execute, newMigration);
+			return false;
+		}
+		await execute.batchCommand(sqls, { timeoutMs: options?.migrationTimeoutMs });
+		await recordMigration(execute, newMigration);
+		return true;
+	} catch (error) {
+		tracer.error("migration-error", {
+			migationName: migration.name,
+			error
+		});
+		throw error;
+	}
 };
-const createSingletonClientConnectionPool = (options) => {
-	const { driverType, dbClient } = options;
-	return createSingletonConnectionPool({
-		getConnection: () => options.connectionFactory({ dbClient }),
-		driverType
-	});
-};
-const createAlwaysNewConnectionPool = (options) => {
-	const { driverType, getConnection, connectionOptions } = options;
-	return createConnectionPool({
-		driverType,
-		getConnection: () => connectionOptions ? getConnection(connectionOptions) : getConnection()
-	});
+const getMigrationHash = async (sqlMigration, sqlFormatter) => {
+	const content = sqlFormatter.describe(sqlMigration.sqls, { serializer: JSONSerializer });
+	const data = new TextEncoder().encode(content);
+	const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+	return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
 };
-const createConnectionPool = (pool) => {
-	const { driverType, getConnection } = pool;
-	const connection = "connection" in pool ? pool.connection : () => Promise.resolve(getConnection());
+const combineMigrations = (...migration) => migration.flatMap((m) => m.sqls);
+const ensureMigrationWasNotAppliedYet = async (execute, migration) => {
+	const result = await singleOrNull(execute.query(SQL`SELECT sql_hash as "sqlHash" FROM dmb_migrations WHERE name = ${migration.name}`));
+	if (result === null) return { exists: false };
+	const { sqlHash } = result;
 	return {
-		driverType,
-		connection,
-		withConnection: "withConnection" in pool ? pool.withConnection : (handle, _options) => executeInNewConnection(handle, { connection }),
-		close: "close" in pool ? pool.close : () => Promise.resolve(),
-		execute: "execute" in pool ? pool.execute : sqlExecutorInNewConnection({
-			driverType,
-			connection
-		}),
-		..."transaction" in pool && "withTransaction" in pool ? {
-			transaction: pool.transaction,
-			withTransaction: pool.withTransaction
-		} : transactionFactoryWithNewConnection(getConnection)
+		exists: true,
+		hashesMatch: sqlHash === migration.sqlHash,
+		hashFromDB: sqlHash
 	};
 };
+const recordMigration = async (execute, migration) => {
+	await execute.command(SQL`
+      INSERT INTO dmb_migrations (name, sql_hash)
+      VALUES (${migration.name}, ${migration.sqlHash})`);
+};
+const updateMigrationHash = async (execute, migration) => {
+	await execute.command(SQL`
+      UPDATE dmb_migrations
+      SET sql_hash = ${migration.sqlHash}, timestamp = ${/* @__PURE__ */ new Date()}
+      WHERE name = ${migration.name}
+      `);
+};
 
 //#endregion
-//#region src/core/index.ts
-SQL.columnN = Object.assign(dumboSchema.column, { type: SQLColumnTypeTokensFactory });
-
-//#endregion
-export { SchemaComponentMigrator as $, JSONCodec as $t, CheckViolationError as A, schemaComponentURN as An, FormatIdentifierProcessor as At, InvalidOperationError as B, IndexURN as Bn, SQLColumnTypeTokens as Bt, mapColumnToDate as C, fromDatabaseDriverType as Cn, TokenizedSQL as Ct, sqlExecutorInAmbientConnection as D, DumboDatabaseDriverRegistry as Dn, SQLProcessorsRegistry as Dt, sqlExecutor as E, toDatabaseDriverType as En, mapDefaultSQLColumnProcessors as Et, DumboError as F, DatabaseSchemaURNType as Fn, BigSerialToken as Ft, SystemError as G, columnSchemaComponent as Gn, VarcharToken as Gt, NotNullViolationError as H, indexSchemaComponent as Hn, SerialToken as Ht, ExclusionViolationError as I, databaseSchemaSchemaComponent as In, ColumnTypeToken as It, MIGRATIONS_LOCK_ID as J, isSchemaComponentOfType as Jn, SQLIn as Jt, TransientDatabaseError as K, filterSchemaComponentsOfType as Kn, SQLArray as Kt, ForeignKeyViolationError as L, TableURN as Ln, IntegerToken as Lt, ConnectionError as M, DatabaseURNType as Mn, SQLProcessor as Mt, DataError as N, databaseSchemaComponent as Nn, AutoIncrementSQLColumnToken as Nt, sqlExecutorInNewConnection as O, canHandleDriverWithConnectionString as On, ExpandArrayProcessor as Ot, DeadlockError as P, DatabaseSchemaURN as Pn, BigIntegerToken as Pt, runSQLMigrations as Q, ParametrizedSQLBuilder as Qt, InsufficientResourcesError as R, TableURNType as Rn, JSONBToken as Rt, mapColumnToBigint as S, resolveDatabaseMetadata as Sn, isSQL as St, mapSQLQueryResult as T, getDatabaseType as Tn, defaultProcessorsRegistry as Tt, QueryCanceledError as U, ColumnURN as Un, TimestampToken as Ut, LockNotAvailableError as V, IndexURNType as Vn, SQLColumnTypeTokensFactory as Vt, SerializationError as W, ColumnURNType as Wn, TimestamptzToken as Wt, getDefaultMigratorOptionsFromRegistry as X, schemaComponent as Xn, SQLPlain as Xt, combineMigrations as Y, mapSchemaComponentsOfType as Yn, SQLLiteral as Yt, registerDefaultMigratorOptions as Z, SQLToken as Zt, transactionFactoryWithNewConnection as _, DumboDatabaseMetadataRegistry as _n, mapSQLIdentifier as _t, createSingletonClientConnectionPool as a, composeJSONReplacers as an, prettyJson as at, executeInNewConnection as b, getDefaultDatabase as bn, RawSQL as bt, TaskProcessor as c, count as cn, describeSQL as ct, createSingletonConnection as d, firstOrNull as dn, registerFormatter as dt, JSONReplacer as en, migrationTableSchemaComponent as et, createTransientConnection as f, single as fn, ANSISQLIdentifierQuote as ft, transactionFactoryWithDbClient as g, dumboSchema as gn, mapANSISQLParamPlaceholder as gt, transactionFactoryWithAsyncAmbientConnection as h, defaultDatabaseLockOptions as hn, SQLValueMapper as ht, createConnectionPool as i, JSONSerializer as in, tracer as it, ConcurrencyError as j, DatabaseURN as jn, MapLiteralProcessor as jt, AdminShutdownError as k, dumboDatabaseDriverRegistry as kn, ExpandSQLInProcessor as kt, createAmbientConnection as l, exists as ln, formatSQL as lt, transactionFactoryWithAmbientConnection as m, NoDatabaseLock as mn, DefaultMapSQLParamValueOptions as mt, createAmbientConnectionPool as n, JSONReviver as nn, LogLevel as nt, createSingletonConnectionPool as o, composeJSONRevivers as on, color as ot, executeInTransaction as p, singleOrNull as pn, ANSISQLParamPlaceholder as pt, UniqueConstraintError as q, findSchemaComponentsOfType as qn, SQLIdentifier as qt, createBoundedConnectionPool as r, JSONRevivers as rn, LogStyle as rt, guardInitializedOnce as s, jsonSerializer as sn, SQLFormatter as st, createAlwaysNewConnectionPool as t, JSONReplacers as tn, sqlMigration as tt, createConnection as u, first as un, getFormatter as ut, BatchCommandNoChangesError as v, dumboDatabaseMetadataRegistry as vn, mapSQLParamValue as vt, mapColumnToJSON as w, getDatabaseDriverName as wn, isTokenizedSQL as wt, executeInNewDbClient as x, getDefaultDatabaseAsync as xn, SQL as xt, executeInAmbientConnection as y, getDatabaseMetadata as yn, ansiSqlReservedMap as yt, IntegrityConstraintViolationError as z, tableSchemaComponent as zn, SQLColumnToken as zt };
-//# sourceMappingURL=core-BG__WVn6.js.map
+export { SQLArray as $, getDatabaseType as $t, TokenizedSQL as A, sqlExecutorInAmbientConnection as An, TableURNType as At, AutoIncrementSQLColumnToken as B, ForeignKeyViolationError as Bn, isSchemaComponentOfType as Bt, mapANSISQLParamPlaceholder as C, executeInNewConnection as Cn, DatabaseURN as Ct, RawSQL as D, mapColumnToJSON as Dn, DatabaseSchemaURNType as Dt, ansiSqlReservedMap as E, mapColumnToDate as En, DatabaseSchemaURN as Et, ExpandArrayProcessor as F, ConnectionError as Fn, ColumnURN as Ft, JSONBToken as G, NotNullViolationError as Gn, first as Gt, BigSerialToken as H, IntegrityConstraintViolationError as Hn, schemaComponent as Ht, ExpandSQLInProcessor as I, DataError as In, ColumnURNType as It, SQLColumnTypeTokensFactory as J, SystemError as Jn, singleOrNull as Jt, SQLColumnToken as K, QueryCanceledError as Kn, firstOrNull as Kt, FormatIdentifierProcessor as L, DeadlockError as Ln, columnSchemaComponent as Lt, defaultProcessorsRegistry as M, AdminShutdownError as Mn, IndexURN as Mt, mapDefaultSQLColumnProcessors as N, CheckViolationError as Nn, IndexURNType as Nt, SQL as O, mapSQLQueryResult as On, databaseSchemaSchemaComponent as Ot, SQLProcessorsRegistry as P, ConcurrencyError as Pn, indexSchemaComponent as Pt, VarcharToken as Q, getDatabaseDriverName as Qt, MapLiteralProcessor as R, DumboError as Rn, filterSchemaComponentsOfType as Rt, SQLValueMapper as S, executeInAmbientConnection as Sn, schemaComponentURN as St, mapSQLParamValue as T, mapColumnToBigint as Tn, databaseSchemaComponent as Tt, ColumnTypeToken as U, InvalidOperationError as Un, count as Ut, BigIntegerToken as V, InsufficientResourcesError as Vn, mapSchemaComponentsOfType as Vt, IntegerToken as W, LockNotAvailableError as Wn, exists as Wt, TimestampToken as X, UniqueConstraintError as Xn, defaultDatabaseLockOptions as Xt, SerialToken as Y, TransientDatabaseError as Yn, NoDatabaseLock as Yt, TimestamptzToken as Z, fromDatabaseDriverType as Zt, getFormatter as _, transactionFactoryWithAmbientConnection as _n, dumboDatabaseMetadataRegistry as _t, runSQLMigrations as a, createAmbientConnectionPool as an, ParametrizedSQLBuilder as at, ANSISQLParamPlaceholder as b, transactionFactoryWithNewConnection as bn, getDefaultDatabaseAsync as bt, sqlMigration as c, createSingletonClientConnectionPool as cn, JSONReplacers as ct, tracer as d, TaskProcessor as dn, JSONSerializer as dt, toDatabaseDriverType as en, SQLIdentifier as et, prettyJson as f, createAmbientConnection as fn, composeJSONReplacers as ft, formatSQL as g, executeInTransaction as gn, DumboDatabaseMetadataRegistry as gt, describeSQL as h, createTransientConnection as hn, dumboSchema as ht, registerDefaultMigratorOptions as i, createAlwaysNewConnectionPool as in, SQLToken as it, isTokenizedSQL as j, sqlExecutorInNewConnection as jn, tableSchemaComponent as jt, isSQL as k, sqlExecutor as kn, TableURN as kt, LogLevel as l, createSingletonConnectionPool as ln, JSONReviver as lt, SQLFormatter as m, createSingletonConnection as mn, jsonSerializer as mt, combineMigrations as n, canHandleDriverWithConnectionString as nn, SQLLiteral as nt, SchemaComponentMigrator as o, createBoundedConnectionPool as on, JSONCodec as ot, color as p, createConnection as pn, composeJSONRevivers as pt, SQLColumnTypeTokens as q, SerializationError as qn, single as qt, getDefaultMigratorOptionsFromRegistry as r, dumboDatabaseDriverRegistry as rn, SQLPlain as rt, migrationTableSchemaComponent as s, createConnectionPool as sn, JSONReplacer as st, MIGRATIONS_LOCK_ID as t, DumboDatabaseDriverRegistry as tn, SQLIn as tt, LogStyle as u, guardInitializedOnce as un, JSONRevivers as ut, registerFormatter as v, transactionFactoryWithAsyncAmbientConnection as vn, getDatabaseMetadata as vt, mapSQLIdentifier as w, executeInNewDbClient as wn, DatabaseURNType as wt, DefaultMapSQLParamValueOptions as x, BatchCommandNoChangesError as xn, resolveDatabaseMetadata as xt, ANSISQLIdentifierQuote as y, transactionFactoryWithDbClient as yn, getDefaultDatabase as yt, SQLProcessor as z, ExclusionViolationError as zn, findSchemaComponentsOfType as zt };
+//# sourceMappingURL=core-IV7or0Mj.js.map