azure-mock 2.20.0 → 2.22.0

package/dist/migrator-CpiXRkls-COYfhljd.js

@@ -0,0 +1,24 @@
+import { C as sql } from "./sql-CNZp2yLp-Bwugq384.js";
+import { t as readMigrationFiles } from "./migrator-DG1mWUoR-DVfkqn_v.js";
+//#region ../db/dist/migrator-CpiXRkls.js
+async function migrate(db, config) {
+	const migrations = readMigrationFiles(config);
+	const migrationsTable = config.migrationsTable ?? "__drizzle_migrations";
+	const migrationTableCreate = sql`
+		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+			id SERIAL PRIMARY KEY,
+			hash text NOT NULL,
+			created_at numeric
+		)
+	`;
+	await db.session.run(migrationTableCreate);
+	const lastDbMigration = (await db.values(sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`))[0] ?? void 0;
+	const statementToBatch = [];
+	for (const migration of migrations) if (!lastDbMigration || Number(lastDbMigration[2]) < migration.folderMillis) {
+		for (const stmt of migration.sql) statementToBatch.push(db.run(sql.raw(stmt)));
+		statementToBatch.push(db.run(sql`INSERT INTO ${sql.identifier(migrationsTable)} ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`));
+	}
+	await db.session.migrate(statementToBatch);
+}
+//#endregion
+export { migrate };

package/dist/migrator-CtqJkLVI-D1lU6ZV0.js

@@ -0,0 +1,8 @@
+import { t as readMigrationFiles } from "./migrator-DG1mWUoR-DVfkqn_v.js";
+//#region ../db/dist/migrator-CtqJkLVI.js
+async function migrate(db, config) {
+	const migrations = readMigrationFiles(config);
+	await db.dialect.migrate(migrations, db.session, config);
+}
+//#endregion
+export { migrate };

package/dist/migrator-CxcBjmET-Dcd21VIf.js

@@ -0,0 +1,8 @@
+import { t as readMigrationFiles } from "./migrator-DG1mWUoR-DVfkqn_v.js";
+//#region ../db/dist/migrator-CxcBjmET.js
+async function migrate(db, config) {
+	const migrations = readMigrationFiles(config);
+	await db.dialect.migrate(migrations, db.session, config);
+}
+//#endregion
+export { migrate };

package/dist/migrator-Cyhbhxo_-Bh7sF0R3.js

@@ -0,0 +1,21 @@
+import { C as sql } from "./sql-CNZp2yLp-Bwugq384.js";
+import { t as readMigrationFiles } from "./migrator-DG1mWUoR-DVfkqn_v.js";
+//#region ../db/dist/migrator-Cyhbhxo_.js
+async function migrate(db, callback, config) {
+	const migrations = readMigrationFiles(config);
+	const migrationsTable = typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
+	const migrationTableCreate = sql`
+		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+			id SERIAL PRIMARY KEY,
+			hash text NOT NULL,
+			created_at numeric
+		)
+	`;
+	await db.run(migrationTableCreate);
+	const lastDbMigration = (await db.values(sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`))[0] ?? void 0;
+	const queriesToRun = [];
+	for (const migration of migrations) if (!lastDbMigration || Number(lastDbMigration[2]) < migration.folderMillis) queriesToRun.push(...migration.sql, `INSERT INTO \`${migrationsTable}\` ("hash", "created_at") VALUES('${migration.hash}', '${migration.folderMillis}')`);
+	await callback(queriesToRun);
+}
+//#endregion
+export { migrate };

package/dist/migrator-DG1mWUoR-DVfkqn_v.js

@@ -0,0 +1,31 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+//#region ../db/dist/migrator-DG1mWUoR.js
+function readMigrationFiles(config) {
+	const migrationFolderTo = config.migrationsFolder;
+	const migrationQueries = [];
+	const journalPath = `${migrationFolderTo}/meta/_journal.json`;
+	if (!fs.existsSync(journalPath)) throw new Error(`Can't find meta/_journal.json file`);
+	const journalAsString = fs.readFileSync(`${migrationFolderTo}/meta/_journal.json`).toString();
+	const journal = JSON.parse(journalAsString);
+	for (const journalEntry of journal.entries) {
+		const migrationPath = `${migrationFolderTo}/${journalEntry.tag}.sql`;
+		try {
+			const query = fs.readFileSync(`${migrationFolderTo}/${journalEntry.tag}.sql`).toString();
+			const result = query.split("--> statement-breakpoint").map((it) => {
+				return it;
+			});
+			migrationQueries.push({
+				sql: result,
+				bps: journalEntry.breakpoints,
+				folderMillis: journalEntry.when,
+				hash: crypto.createHash("sha256").update(query).digest("hex")
+			});
+		} catch {
+			throw new Error(`No file ${migrationPath} found in ${migrationFolderTo} folder`);
+		}
+	}
+	return migrationQueries;
+}
+//#endregion
+export { readMigrationFiles as t };

package/dist/migrator-DrWmHwY2-YjAfotd7.js

@@ -0,0 +1,8 @@
+import { t as readMigrationFiles } from "./migrator-DG1mWUoR-DVfkqn_v.js";
+//#region ../db/dist/migrator-DrWmHwY2.js
+async function migrate(db, config) {
+	const migrations = readMigrationFiles(config);
+	await db.dialect.migrate(migrations, db.session, config);
+}
+//#endregion
+export { migrate };

package/dist/migrator-WAPonQxA-CRvJJhKG.js

@@ -0,0 +1,8 @@
+import { t as readMigrationFiles } from "./migrator-DG1mWUoR-DVfkqn_v.js";
+//#region ../db/dist/migrator-WAPonQxA.js
+async function migrate(db, config) {
+	const migrations = readMigrationFiles(config);
+	await db.dialect.migrate(migrations, db.session, config);
+}
+//#endregion
+export { migrate };

package/dist/migrator-Zdh8WMMx-gsmNXspd.js

@@ -0,0 +1,8 @@
+import { t as readMigrationFiles } from "./migrator-DG1mWUoR-DVfkqn_v.js";
+//#region ../db/dist/migrator-Zdh8WMMx.js
+async function migrate(db, config) {
+	const migrations = readMigrationFiles(config);
+	await db.dialect.migrate(migrations, db.session, config);
+}
+//#endregion
+export { migrate };

package/dist/migrator-xRJ6NOTS-SsAuB-Gi.js

@@ -0,0 +1,24 @@
+import { C as sql } from "./sql-CNZp2yLp-Bwugq384.js";
+import { t as readMigrationFiles } from "./migrator-DG1mWUoR-DVfkqn_v.js";
+//#region ../db/dist/migrator-xRJ6NOTS.js
+async function migrate(db, config) {
+	const migrations = readMigrationFiles(config);
+	const migrationsTable = config.migrationsTable ?? "__drizzle_migrations";
+	const migrationTableCreate = sql`
+		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
+			id SERIAL PRIMARY KEY,
+			hash text NOT NULL,
+			created_at numeric
+		)
+	`;
+	await db.session.run(migrationTableCreate);
+	const lastDbMigration = (await db.values(sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`))[0] ?? void 0;
+	const statementToBatch = [];
+	for (const migration of migrations) if (!lastDbMigration || Number(lastDbMigration[2]) < migration.folderMillis) {
+		for (const stmt of migration.sql) statementToBatch.push(db.run(sql.raw(stmt)));
+		statementToBatch.push(db.run(sql`INSERT INTO ${sql.identifier(migrationsTable)} ("hash", "created_at") VALUES(${sql.raw(`'${migration.hash}'`)}, ${sql.raw(`${migration.folderMillis}`)})`));
+	}
+	if (statementToBatch.length > 0) await db.session.batch(statementToBatch);
+}
+//#endregion
+export { migrate };

package/dist/migrator-xbWwvFYF-BjyVdQS8.js

@@ -0,0 +1,8 @@
+import { t as readMigrationFiles } from "./migrator-DG1mWUoR-DVfkqn_v.js";
+//#region ../db/dist/migrator-xbWwvFYF.js
+async function migrate(db, config) {
+	const migrations = readMigrationFiles(config);
+	await db.dialect.migrate(migrations, db.session, config);
+}
+//#endregion
+export { migrate };

package/dist/mysql2-DkoPEsRu-BMwVSCmY.js

@@ -0,0 +1,251 @@
+import { C as sql, _ as fillPlaceholders, b as is, g as entityKind, t as Column } from "./sql-CNZp2yLp-Bwugq384.js";
+import { M as mapResultRow, O as isConfig, n as DefaultLogger, o as NoopCache, r as DrizzleError, s as NoopLogger, x as extractTablesRelationalConfig, y as createTableRelationsHelpers } from "./logger-TIsK7375-CLNNa25D.js";
+import { t as MySqlDialect } from "./query-builder-CLJAKedv-DTZiP7B6.js";
+import { i as MySqlTransaction, n as MySqlPreparedQuery, r as MySqlSession, t as MySqlDatabase } from "./session-CAUQtT0A-BoVK2x7A.js";
+import { createPool } from "mysql2";
+import { once } from "node:events";
+//#region ../db/dist/mysql2-DkoPEsRu.js
+var MySql2PreparedQuery = class extends MySqlPreparedQuery {
+	constructor(client, queryString, params, logger, cache, queryMetadata, cacheConfig, fields, customResultMapper, generatedIds, returningIds) {
+		super(cache, queryMetadata, cacheConfig);
+		this.client = client;
+		this.params = params;
+		this.logger = logger;
+		this.fields = fields;
+		this.customResultMapper = customResultMapper;
+		this.generatedIds = generatedIds;
+		this.returningIds = returningIds;
+		this.rawQuery = {
+			sql: queryString,
+			typeCast: function(field, next) {
+				if (field.type === "TIMESTAMP" || field.type === "DATETIME" || field.type === "DATE") return field.string();
+				return next();
+			}
+		};
+		this.query = {
+			sql: queryString,
+			rowsAsArray: true,
+			typeCast: function(field, next) {
+				if (field.type === "TIMESTAMP" || field.type === "DATETIME" || field.type === "DATE") return field.string();
+				return next();
+			}
+		};
+	}
+	static [entityKind] = "MySql2PreparedQuery";
+	rawQuery;
+	query;
+	async execute(placeholderValues = {}) {
+		const params = fillPlaceholders(this.params, placeholderValues);
+		this.logger.logQuery(this.rawQuery.sql, params);
+		const { fields, client, rawQuery, query, joinsNotNullableMap, customResultMapper, returningIds, generatedIds } = this;
+		if (!fields && !customResultMapper) {
+			const res = await this.queryWithCache(rawQuery.sql, params, async () => {
+				return await client.query(rawQuery, params);
+			});
+			const insertId = res[0].insertId;
+			const affectedRows = res[0].affectedRows;
+			if (returningIds) {
+				const returningResponse = [];
+				let j = 0;
+				for (let i = insertId; i < insertId + affectedRows; i++) {
+					for (const column of returningIds) {
+						const key = returningIds[0].path[0];
+						if (is(column.field, Column)) {
+							if (column.field.primary && column.field.autoIncrement) returningResponse.push({ [key]: i });
+							if (column.field.defaultFn && generatedIds) returningResponse.push({ [key]: generatedIds[j][key] });
+						}
+					}
+					j++;
+				}
+				return returningResponse;
+			}
+			return res;
+		}
+		const rows = (await this.queryWithCache(query.sql, params, async () => {
+			return await client.query(query, params);
+		}))[0];
+		if (customResultMapper) return customResultMapper(rows);
+		return rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
+	}
+	async *iterator(placeholderValues = {}) {
+		const params = fillPlaceholders(this.params, placeholderValues);
+		const conn = (isPool(this.client) ? await this.client.getConnection() : this.client).connection;
+		const { fields, query, rawQuery, joinsNotNullableMap, client, customResultMapper } = this;
+		const hasRowsMapper = Boolean(fields || customResultMapper);
+		const stream = (hasRowsMapper ? conn.query(query, params) : conn.query(rawQuery, params)).stream();
+		function dataListener() {
+			stream.pause();
+		}
+		stream.on("data", dataListener);
+		try {
+			const onEnd = once(stream, "end");
+			const onError = once(stream, "error");
+			while (true) {
+				stream.resume();
+				const row = await Promise.race([
+					onEnd,
+					onError,
+					new Promise((resolve) => stream.once("data", resolve))
+				]);
+				if (row === void 0 || Array.isArray(row) && row.length === 0) break;
+				else if (row instanceof Error) throw row;
+				else if (hasRowsMapper) if (customResultMapper) {
+					const mappedRow = customResultMapper([row]);
+					yield Array.isArray(mappedRow) ? mappedRow[0] : mappedRow;
+				} else yield mapResultRow(fields, row, joinsNotNullableMap);
+				else yield row;
+			}
+		} finally {
+			stream.off("data", dataListener);
+			if (isPool(client)) conn.end();
+		}
+	}
+};
+var MySql2Session = class MySql2Session extends MySqlSession {
+	constructor(client, dialect, schema, options) {
+		super(dialect);
+		this.client = client;
+		this.schema = schema;
+		this.options = options;
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+		this.mode = options.mode;
+	}
+	static [entityKind] = "MySql2Session";
+	logger;
+	mode;
+	cache;
+	prepareQuery(query, fields, customResultMapper, generatedIds, returningIds, queryMetadata, cacheConfig) {
+		return new MySql2PreparedQuery(this.client, query.sql, query.params, this.logger, this.cache, queryMetadata, cacheConfig, fields, customResultMapper, generatedIds, returningIds);
+	}
+	/**
+	* @internal
+	* What is its purpose?
+	*/
+	async query(query, params) {
+		this.logger.logQuery(query, params);
+		return await this.client.query({
+			sql: query,
+			values: params,
+			rowsAsArray: true,
+			typeCast: function(field, next) {
+				if (field.type === "TIMESTAMP" || field.type === "DATETIME" || field.type === "DATE") return field.string();
+				return next();
+			}
+		});
+	}
+	all(query) {
+		const querySql = this.dialect.sqlToQuery(query);
+		this.logger.logQuery(querySql.sql, querySql.params);
+		return this.client.execute(querySql.sql, querySql.params).then((result) => result[0]);
+	}
+	async transaction(transaction, config) {
+		const session = isPool(this.client) ? new MySql2Session(await this.client.getConnection(), this.dialect, this.schema, this.options) : this;
+		const tx = new MySql2Transaction(this.dialect, session, this.schema, 0, this.mode);
+		if (config) {
+			const setTransactionConfigSql = this.getSetTransactionSQL(config);
+			if (setTransactionConfigSql) await tx.execute(setTransactionConfigSql);
+			const startTransactionSql = this.getStartTransactionSQL(config);
+			await (startTransactionSql ? tx.execute(startTransactionSql) : tx.execute(sql`begin`));
+		} else await tx.execute(sql`begin`);
+		try {
+			const result = await transaction(tx);
+			await tx.execute(sql`commit`);
+			return result;
+		} catch (err) {
+			await tx.execute(sql`rollback`);
+			throw err;
+		} finally {
+			if (isPool(this.client)) session.client.release();
+		}
+	}
+};
+var MySql2Transaction = class MySql2Transaction extends MySqlTransaction {
+	static [entityKind] = "MySql2Transaction";
+	async transaction(transaction) {
+		const savepointName = `sp${this.nestedIndex + 1}`;
+		const tx = new MySql2Transaction(this.dialect, this.session, this.schema, this.nestedIndex + 1, this.mode);
+		await tx.execute(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = await transaction(tx);
+			await tx.execute(sql.raw(`release savepoint ${savepointName}`));
+			return result;
+		} catch (err) {
+			await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw err;
+		}
+	}
+};
+function isPool(client) {
+	return "getConnection" in client;
+}
+var MySql2Driver = class {
+	constructor(client, dialect, options = {}) {
+		this.client = client;
+		this.dialect = dialect;
+		this.options = options;
+	}
+	static [entityKind] = "MySql2Driver";
+	createSession(schema, mode) {
+		return new MySql2Session(this.client, this.dialect, schema, {
+			logger: this.options.logger,
+			mode,
+			cache: this.options.cache
+		});
+	}
+};
+var MySql2Database = class extends MySqlDatabase {
+	static [entityKind] = "MySql2Database";
+};
+function construct(client, config = {}) {
+	const dialect = new MySqlDialect({ casing: config.casing });
+	let logger;
+	if (config.logger === true) logger = new DefaultLogger();
+	else if (config.logger !== false) logger = config.logger;
+	const clientForInstance = isCallbackClient(client) ? client.promise() : client;
+	let schema;
+	if (config.schema) {
+		if (config.mode === void 0) throw new DrizzleError({ message: "You need to specify \"mode\": \"planetscale\" or \"default\" when providing a schema. Read more: https://orm.drizzle.team/docs/rqb#modes" });
+		const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
+		schema = {
+			fullSchema: config.schema,
+			schema: tablesConfig.tables,
+			tableNamesMap: tablesConfig.tableNamesMap
+		};
+	}
+	const mode = config.mode ?? "default";
+	const db = new MySql2Database(dialect, new MySql2Driver(clientForInstance, dialect, {
+		logger,
+		cache: config.cache
+	}).createSession(schema, mode), schema, mode);
+	db.$client = client;
+	db.$cache = config.cache;
+	if (db.$cache) db.$cache["invalidate"] = config.cache?.onMutate;
+	return db;
+}
+function isCallbackClient(client) {
+	return typeof client.promise === "function";
+}
+function drizzle(...params) {
+	if (typeof params[0] === "string") {
+		const connectionString = params[0];
+		return construct(createPool({ uri: connectionString }), params[1]);
+	}
+	if (isConfig(params[0])) {
+		const { connection, client, ...drizzleConfig } = params[0];
+		if (client) return construct(client, drizzleConfig);
+		return construct(typeof connection === "string" ? createPool({
+			uri: connection,
+			supportBigNumbers: true
+		}) : createPool(connection), drizzleConfig);
+	}
+	return construct(params[0], params[1]);
+}
+((drizzle2) => {
+	function mock(config) {
+		return construct({}, config);
+	}
+	drizzle2.mock = mock;
+})(drizzle || (drizzle = {}));
+//#endregion
+export { drizzle };

package/dist/neon-serverless-BEVFA7yv-DGSPAG1z.js

@@ -0,0 +1,205 @@
+import { C as sql, _ as fillPlaceholders, g as entityKind } from "./sql-CNZp2yLp-Bwugq384.js";
+import { M as mapResultRow, O as isConfig, n as DefaultLogger, o as NoopCache, s as NoopLogger, x as extractTablesRelationalConfig, y as createTableRelationsHelpers } from "./logger-TIsK7375-CLNNa25D.js";
+import { a as PgTransaction, i as PgSession, n as PgDialect, r as PgPreparedQuery, t as PgDatabase } from "./session-BOEirggu-DTmpyU_x.js";
+import { Pool, neonConfig, types } from "@neondatabase/serverless";
+//#region ../db/dist/neon-serverless-BEVFA7yv.js
+var NeonPreparedQuery = class extends PgPreparedQuery {
+	constructor(client, queryString, params, logger, cache, queryMetadata, cacheConfig, fields, name, _isResponseInArrayMode, customResultMapper) {
+		super({
+			sql: queryString,
+			params
+		}, cache, queryMetadata, cacheConfig);
+		this.client = client;
+		this.params = params;
+		this.logger = logger;
+		this.fields = fields;
+		this._isResponseInArrayMode = _isResponseInArrayMode;
+		this.customResultMapper = customResultMapper;
+		this.rawQueryConfig = {
+			name,
+			text: queryString,
+			types: { getTypeParser: (typeId, format) => {
+				if (typeId === types.builtins.TIMESTAMPTZ) return (val) => val;
+				if (typeId === types.builtins.TIMESTAMP) return (val) => val;
+				if (typeId === types.builtins.DATE) return (val) => val;
+				if (typeId === types.builtins.INTERVAL) return (val) => val;
+				if (typeId === 1231) return (val) => val;
+				if (typeId === 1115) return (val) => val;
+				if (typeId === 1185) return (val) => val;
+				if (typeId === 1187) return (val) => val;
+				if (typeId === 1182) return (val) => val;
+				return types.getTypeParser(typeId, format);
+			} }
+		};
+		this.queryConfig = {
+			name,
+			text: queryString,
+			rowMode: "array",
+			types: { getTypeParser: (typeId, format) => {
+				if (typeId === types.builtins.TIMESTAMPTZ) return (val) => val;
+				if (typeId === types.builtins.TIMESTAMP) return (val) => val;
+				if (typeId === types.builtins.DATE) return (val) => val;
+				if (typeId === types.builtins.INTERVAL) return (val) => val;
+				if (typeId === 1231) return (val) => val;
+				if (typeId === 1115) return (val) => val;
+				if (typeId === 1185) return (val) => val;
+				if (typeId === 1187) return (val) => val;
+				if (typeId === 1182) return (val) => val;
+				return types.getTypeParser(typeId, format);
+			} }
+		};
+	}
+	static [entityKind] = "NeonPreparedQuery";
+	rawQueryConfig;
+	queryConfig;
+	async execute(placeholderValues = {}) {
+		const params = fillPlaceholders(this.params, placeholderValues);
+		this.logger.logQuery(this.rawQueryConfig.text, params);
+		const { fields, client, rawQueryConfig: rawQuery, queryConfig: query, joinsNotNullableMap, customResultMapper } = this;
+		if (!fields && !customResultMapper) return await this.queryWithCache(rawQuery.text, params, async () => {
+			return await client.query(rawQuery, params);
+		});
+		const result = await this.queryWithCache(query.text, params, async () => {
+			return await client.query(query, params);
+		});
+		return customResultMapper ? customResultMapper(result.rows) : result.rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
+	}
+	all(placeholderValues = {}) {
+		const params = fillPlaceholders(this.params, placeholderValues);
+		this.logger.logQuery(this.rawQueryConfig.text, params);
+		return this.queryWithCache(this.rawQueryConfig.text, params, async () => {
+			return await this.client.query(this.rawQueryConfig, params);
+		}).then((result) => result.rows);
+	}
+	values(placeholderValues = {}) {
+		const params = fillPlaceholders(this.params, placeholderValues);
+		this.logger.logQuery(this.rawQueryConfig.text, params);
+		return this.queryWithCache(this.queryConfig.text, params, async () => {
+			return await this.client.query(this.queryConfig, params);
+		}).then((result) => result.rows);
+	}
+	/** @internal */
+	isResponseInArrayMode() {
+		return this._isResponseInArrayMode;
+	}
+};
+var NeonSession = class NeonSession extends PgSession {
+	constructor(client, dialect, schema, options = {}) {
+		super(dialect);
+		this.client = client;
+		this.schema = schema;
+		this.options = options;
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+	}
+	static [entityKind] = "NeonSession";
+	logger;
+	cache;
+	prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
+		return new NeonPreparedQuery(this.client, query.sql, query.params, this.logger, this.cache, queryMetadata, cacheConfig, fields, name, isResponseInArrayMode, customResultMapper);
+	}
+	async query(query, params) {
+		this.logger.logQuery(query, params);
+		return await this.client.query({
+			rowMode: "array",
+			text: query,
+			values: params
+		});
+	}
+	async queryObjects(query, params) {
+		return this.client.query(query, params);
+	}
+	async count(sql2) {
+		const res = await this.execute(sql2);
+		return Number(res["rows"][0]["count"]);
+	}
+	async transaction(transaction, config = {}) {
+		const session = this.client instanceof Pool ? new NeonSession(await this.client.connect(), this.dialect, this.schema, this.options) : this;
+		const tx = new NeonTransaction(this.dialect, session, this.schema);
+		await tx.execute(sql`begin ${tx.getTransactionConfigSQL(config)}`);
+		try {
+			const result = await transaction(tx);
+			await tx.execute(sql`commit`);
+			return result;
+		} catch (error) {
+			await tx.execute(sql`rollback`);
+			throw error;
+		} finally {
+			if (this.client instanceof Pool) session.client.release();
+		}
+	}
+};
+var NeonTransaction = class NeonTransaction extends PgTransaction {
+	static [entityKind] = "NeonTransaction";
+	async transaction(transaction) {
+		const savepointName = `sp${this.nestedIndex + 1}`;
+		const tx = new NeonTransaction(this.dialect, this.session, this.schema, this.nestedIndex + 1);
+		await tx.execute(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = await transaction(tx);
+			await tx.execute(sql.raw(`release savepoint ${savepointName}`));
+			return result;
+		} catch (e) {
+			await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw e;
+		}
+	}
+};
+var NeonDriver = class {
+	constructor(client, dialect, options = {}) {
+		this.client = client;
+		this.dialect = dialect;
+		this.options = options;
+	}
+	static [entityKind] = "NeonDriver";
+	createSession(schema) {
+		return new NeonSession(this.client, this.dialect, schema, {
+			logger: this.options.logger,
+			cache: this.options.cache
+		});
+	}
+};
+var NeonDatabase = class extends PgDatabase {
+	static [entityKind] = "NeonServerlessDatabase";
+};
+function construct(client, config = {}) {
+	const dialect = new PgDialect({ casing: config.casing });
+	let logger;
+	if (config.logger === true) logger = new DefaultLogger();
+	else if (config.logger !== false) logger = config.logger;
+	let schema;
+	if (config.schema) {
+		const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
+		schema = {
+			fullSchema: config.schema,
+			schema: tablesConfig.tables,
+			tableNamesMap: tablesConfig.tableNamesMap
+		};
+	}
+	const db = new NeonDatabase(dialect, new NeonDriver(client, dialect, {
+		logger,
+		cache: config.cache
+	}).createSession(schema), schema);
+	db.$client = client;
+	db.$cache = config.cache;
+	if (db.$cache) db.$cache["invalidate"] = config.cache?.onMutate;
+	return db;
+}
+function drizzle(...params) {
+	if (typeof params[0] === "string") return construct(new Pool({ connectionString: params[0] }), params[1]);
+	if (isConfig(params[0])) {
+		const { connection, client, ws, ...drizzleConfig } = params[0];
+		if (ws) neonConfig.webSocketConstructor = ws;
+		if (client) return construct(client, drizzleConfig);
+		return construct(typeof connection === "string" ? new Pool({ connectionString: connection }) : new Pool(connection), drizzleConfig);
+	}
+	return construct(params[0], params[1]);
+}
+((drizzle2) => {
+	function mock(config) {
+		return construct({}, config);
+	}
+	drizzle2.mock = mock;
+})(drizzle || (drizzle = {}));
+//#endregion
+export { drizzle };