azure-mock 2.20.0 → 2.22.0

package/dist/pg-ylxXyvKj-Hm8vcZoi.js

@@ -0,0 +1,279 @@
+import { C as sql, _ as fillPlaceholders, b as is, d as Table, g as entityKind, i as PgArray, r as Param } from "./sql-CNZp2yLp-Bwugq384.js";
+import { M as mapResultRow, n as DefaultLogger, o as NoopCache, 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 { BeginTransactionCommand, CommitTransactionCommand, ExecuteStatementCommand, RDSDataClient, RollbackTransactionCommand, TypeHint } from "@aws-sdk/client-rds-data";
+//#region ../db/dist/pg-ylxXyvKj.js
+function getValueFromDataApi(field) {
+	if (field.stringValue !== void 0) return field.stringValue;
+	else if (field.booleanValue !== void 0) return field.booleanValue;
+	else if (field.doubleValue !== void 0) return field.doubleValue;
+	else if (field.isNull !== void 0) return null;
+	else if (field.longValue !== void 0) return field.longValue;
+	else if (field.blobValue !== void 0) return field.blobValue;
+	else if (field.arrayValue !== void 0) {
+		if (field.arrayValue.stringValues !== void 0) return field.arrayValue.stringValues;
+		if (field.arrayValue.longValues !== void 0) return field.arrayValue.longValues;
+		if (field.arrayValue.doubleValues !== void 0) return field.arrayValue.doubleValues;
+		if (field.arrayValue.booleanValues !== void 0) return field.arrayValue.booleanValues;
+		if (field.arrayValue.arrayValues !== void 0) return field.arrayValue.arrayValues;
+		throw new Error("Unknown array type");
+	} else throw new Error("Unknown type");
+}
+function typingsToAwsTypeHint(typings) {
+	if (typings === "date") return TypeHint.DATE;
+	else if (typings === "decimal") return TypeHint.DECIMAL;
+	else if (typings === "json") return TypeHint.JSON;
+	else if (typings === "time") return TypeHint.TIME;
+	else if (typings === "timestamp") return TypeHint.TIMESTAMP;
+	else if (typings === "uuid") return TypeHint.UUID;
+	else return;
+}
+function toValueParam(value, typings) {
+	const response = {
+		value: {},
+		typeHint: typingsToAwsTypeHint(typings)
+	};
+	if (value === null) response.value = { isNull: true };
+	else if (typeof value === "string") switch (response.typeHint) {
+		case TypeHint.DATE:
+			response.value = { stringValue: value.split("T")[0] };
+			break;
+		case TypeHint.TIMESTAMP:
+			response.value = { stringValue: value.replace("T", " ").replace("Z", "") };
+			break;
+		default:
+			response.value = { stringValue: value };
+			break;
+	}
+	else if (typeof value === "number" && Number.isInteger(value)) response.value = { longValue: value };
+	else if (typeof value === "number" && !Number.isInteger(value)) response.value = { doubleValue: value };
+	else if (typeof value === "boolean") response.value = { booleanValue: value };
+	else if (value instanceof Date) response.value = { stringValue: value.toISOString().replace("T", " ").replace("Z", "") };
+	else throw new Error(`Unknown type for ${value}`);
+	return response;
+}
+var AwsDataApiPreparedQuery = class extends PgPreparedQuery {
+	constructor(client, queryString, params, typings, options, cache, queryMetadata, cacheConfig, fields, transactionId, _isResponseInArrayMode, customResultMapper) {
+		super({
+			sql: queryString,
+			params
+		}, cache, queryMetadata, cacheConfig);
+		this.client = client;
+		this.queryString = queryString;
+		this.params = params;
+		this.typings = typings;
+		this.options = options;
+		this.fields = fields;
+		this.transactionId = transactionId;
+		this._isResponseInArrayMode = _isResponseInArrayMode;
+		this.customResultMapper = customResultMapper;
+		this.rawQuery = new ExecuteStatementCommand({
+			sql: queryString,
+			parameters: [],
+			secretArn: options.secretArn,
+			resourceArn: options.resourceArn,
+			database: options.database,
+			transactionId,
+			includeResultMetadata: !fields && !customResultMapper
+		});
+	}
+	static [entityKind] = "AwsDataApiPreparedQuery";
+	rawQuery;
+	async execute(placeholderValues = {}) {
+		const { fields, joinsNotNullableMap, customResultMapper } = this;
+		const result = await this.values(placeholderValues);
+		if (!fields && !customResultMapper) {
+			const { columnMetadata, rows } = result;
+			if (!columnMetadata) return result;
+			const mappedRows = rows.map((sourceRow) => {
+				const row = {};
+				for (const [index, value] of sourceRow.entries()) {
+					const metadata = columnMetadata[index];
+					if (!metadata) throw new Error(`Unexpected state: no column metadata found for index ${index}. Please report this issue on GitHub: https://github.com/drizzle-team/drizzle-orm/issues/new/choose`);
+					if (!metadata.name) throw new Error(`Unexpected state: no column name for index ${index} found in the column metadata. Please report this issue on GitHub: https://github.com/drizzle-team/drizzle-orm/issues/new/choose`);
+					row[metadata.name] = value;
+				}
+				return row;
+			});
+			return Object.assign(result, { rows: mappedRows });
+		}
+		return customResultMapper ? customResultMapper(result.rows) : result.rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
+	}
+	async all(placeholderValues) {
+		const result = await this.execute(placeholderValues);
+		if (!this.fields && !this.customResultMapper) return result.rows;
+		return result;
+	}
+	async values(placeholderValues = {}) {
+		const params = fillPlaceholders(this.params, placeholderValues ?? {});
+		this.rawQuery.input.parameters = params.map((param, index) => ({
+			name: `${index + 1}`,
+			...toValueParam(param, this.typings[index])
+		}));
+		this.options.logger?.logQuery(this.rawQuery.input.sql, this.rawQuery.input.parameters);
+		const result = await this.queryWithCache(this.queryString, params, async () => {
+			return await this.client.send(this.rawQuery);
+		});
+		const rows = result.records?.map((row) => {
+			return row.map((field) => getValueFromDataApi(field));
+		}) ?? [];
+		return {
+			...result,
+			rows
+		};
+	}
+	/** @internal */
+	mapResultRows(records, columnMetadata) {
+		return records.map((record) => {
+			const row = {};
+			for (const [index, field] of record.entries()) {
+				const { name } = columnMetadata[index];
+				row[name ?? index] = getValueFromDataApi(field);
+			}
+			return row;
+		});
+	}
+	/** @internal */
+	isResponseInArrayMode() {
+		return this._isResponseInArrayMode;
+	}
+};
+var AwsDataApiSession = class AwsDataApiSession extends PgSession {
+	constructor(client, dialect, schema, options, transactionId) {
+		super(dialect);
+		this.client = client;
+		this.schema = schema;
+		this.options = options;
+		this.transactionId = transactionId;
+		this.rawQuery = {
+			secretArn: options.secretArn,
+			resourceArn: options.resourceArn,
+			database: options.database
+		};
+		this.cache = options.cache ?? new NoopCache();
+	}
+	static [entityKind] = "AwsDataApiSession";
+	/** @internal */
+	rawQuery;
+	cache;
+	prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig, transactionId) {
+		return new AwsDataApiPreparedQuery(this.client, query.sql, query.params, query.typings ?? [], this.options, this.cache, queryMetadata, cacheConfig, fields, transactionId ?? this.transactionId, isResponseInArrayMode, customResultMapper);
+	}
+	execute(query) {
+		return this.prepareQuery(this.dialect.sqlToQuery(query), void 0, void 0, false, void 0, void 0, void 0, this.transactionId).execute();
+	}
+	async transaction(transaction, config) {
+		const { transactionId } = await this.client.send(new BeginTransactionCommand(this.rawQuery));
+		const session = new AwsDataApiSession(this.client, this.dialect, this.schema, this.options, transactionId);
+		const tx = new AwsDataApiTransaction(this.dialect, session, this.schema);
+		if (config) await tx.setTransaction(config);
+		try {
+			const result = await transaction(tx);
+			await this.client.send(new CommitTransactionCommand({
+				...this.rawQuery,
+				transactionId
+			}));
+			return result;
+		} catch (e) {
+			await this.client.send(new RollbackTransactionCommand({
+				...this.rawQuery,
+				transactionId
+			}));
+			throw e;
+		}
+	}
+};
+var AwsDataApiTransaction = class AwsDataApiTransaction extends PgTransaction {
+	static [entityKind] = "AwsDataApiTransaction";
+	async transaction(transaction) {
+		const savepointName = `sp${this.nestedIndex + 1}`;
+		const tx = new AwsDataApiTransaction(this.dialect, this.session, this.schema, this.nestedIndex + 1);
+		await this.session.execute(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = await transaction(tx);
+			await this.session.execute(sql.raw(`release savepoint ${savepointName}`));
+			return result;
+		} catch (e) {
+			await this.session.execute(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw e;
+		}
+	}
+};
+var AwsDataApiPgDatabase = class extends PgDatabase {
+	static [entityKind] = "AwsDataApiPgDatabase";
+	execute(query) {
+		return super.execute(query);
+	}
+};
+var AwsPgDialect = class extends PgDialect {
+	static [entityKind] = "AwsPgDialect";
+	escapeParam(num) {
+		return `:${num + 1}`;
+	}
+	buildInsertQuery({ table, values, onConflict, returning, select, withList }) {
+		const columns = table[Table.Symbol.Columns];
+		if (!select) for (const value of values) for (const fieldName of Object.keys(columns)) {
+			const colValue = value[fieldName];
+			if (is(colValue, Param) && colValue.value !== void 0 && is(colValue.encoder, PgArray) && Array.isArray(colValue.value)) value[fieldName] = sql`cast(${colValue} as ${sql.raw(colValue.encoder.getSQLType())})`;
+		}
+		return super.buildInsertQuery({
+			table,
+			values,
+			onConflict,
+			returning,
+			withList
+		});
+	}
+	buildUpdateSet(table, set) {
+		const columns = table[Table.Symbol.Columns];
+		for (const [colName, colValue] of Object.entries(set)) if (columns[colName] && is(colValue, Param) && colValue.value !== void 0 && is(colValue.encoder, PgArray) && Array.isArray(colValue.value)) set[colName] = sql`cast(${colValue} as ${sql.raw(colValue.encoder.getSQLType())})`;
+		return super.buildUpdateSet(table, set);
+	}
+};
+function construct(client, config) {
+	const dialect = new AwsPgDialect({ 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 AwsDataApiPgDatabase(dialect, new AwsDataApiSession(client, dialect, schema, {
+		...config,
+		logger,
+		cache: config.cache
+	}, void 0), schema);
+	db.$client = client;
+	db.$cache = config.cache;
+	if (db.$cache) db.$cache["invalidate"] = config.cache?.onMutate;
+	return db;
+}
+function drizzle(...params) {
+	if (params[0] instanceof RDSDataClient || params[0].constructor.name !== "Object") return construct(params[0], params[1]);
+	if (params[0].client) {
+		const { client, ...drizzleConfig2 } = params[0];
+		return construct(client, drizzleConfig2);
+	}
+	const { connection, ...drizzleConfig } = params[0];
+	const { resourceArn, database, secretArn, ...rdsConfig } = connection;
+	return construct(new RDSDataClient(rdsConfig), {
+		resourceArn,
+		database,
+		secretArn,
+		...drizzleConfig
+	});
+}
+((drizzle2) => {
+	function mock(config) {
+		return construct({}, config);
+	}
+	drizzle2.mock = mock;
+})(drizzle || (drizzle = {}));
+//#endregion
+export { AwsDataApiSession, drizzle };

package/dist/pglite-CPs4w-D9-DHOg0D8W.js

@@ -0,0 +1,179 @@
+import { n as dn, t as Xe } from "./dist-C481edUb-CHbOkeXH.js";
+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";
+//#region ../db/dist/pglite-CPs4w-D9.js
+var PglitePreparedQuery = 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.queryString = queryString;
+		this.params = params;
+		this.logger = logger;
+		this.fields = fields;
+		this._isResponseInArrayMode = _isResponseInArrayMode;
+		this.customResultMapper = customResultMapper;
+		this.rawQueryConfig = {
+			rowMode: "object",
+			parsers: {
+				[dn.TIMESTAMP]: (value) => value,
+				[dn.TIMESTAMPTZ]: (value) => value,
+				[dn.INTERVAL]: (value) => value,
+				[dn.DATE]: (value) => value,
+				[1231]: (value) => value,
+				[1115]: (value) => value,
+				[1185]: (value) => value,
+				[1187]: (value) => value,
+				[1182]: (value) => value
+			}
+		};
+		this.queryConfig = {
+			rowMode: "array",
+			parsers: {
+				[dn.TIMESTAMP]: (value) => value,
+				[dn.TIMESTAMPTZ]: (value) => value,
+				[dn.INTERVAL]: (value) => value,
+				[dn.DATE]: (value) => value,
+				[1231]: (value) => value,
+				[1115]: (value) => value,
+				[1185]: (value) => value,
+				[1187]: (value) => value,
+				[1182]: (value) => value
+			}
+		};
+	}
+	static [entityKind] = "PglitePreparedQuery";
+	rawQueryConfig;
+	queryConfig;
+	async execute(placeholderValues = {}) {
+		const params = fillPlaceholders(this.params, placeholderValues);
+		this.logger.logQuery(this.queryString, params);
+		const { fields, client, queryConfig, joinsNotNullableMap, customResultMapper, queryString, rawQueryConfig } = this;
+		if (!fields && !customResultMapper) return this.queryWithCache(queryString, params, async () => {
+			return await client.query(queryString, params, rawQueryConfig);
+		});
+		const result = await this.queryWithCache(queryString, params, async () => {
+			return await client.query(queryString, params, queryConfig);
+		});
+		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.queryString, params);
+		return this.queryWithCache(this.queryString, params, async () => {
+			return await this.client.query(this.queryString, params, this.rawQueryConfig);
+		}).then((result) => result.rows);
+	}
+	/** @internal */
+	isResponseInArrayMode() {
+		return this._isResponseInArrayMode;
+	}
+};
+var PgliteSession = class PgliteSession 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] = "PgliteSession";
+	logger;
+	cache;
+	prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
+		return new PglitePreparedQuery(this.client, query.sql, query.params, this.logger, this.cache, queryMetadata, cacheConfig, fields, name, isResponseInArrayMode, customResultMapper);
+	}
+	async transaction(transaction, config) {
+		return this.client.transaction(async (client) => {
+			const session = new PgliteSession(client, this.dialect, this.schema, this.options);
+			const tx = new PgliteTransaction(this.dialect, session, this.schema);
+			if (config) await tx.setTransaction(config);
+			return transaction(tx);
+		});
+	}
+	async count(sql2) {
+		const res = await this.execute(sql2);
+		return Number(res["rows"][0]["count"]);
+	}
+};
+var PgliteTransaction = class PgliteTransaction extends PgTransaction {
+	static [entityKind] = "PgliteTransaction";
+	async transaction(transaction) {
+		const savepointName = `sp${this.nestedIndex + 1}`;
+		const tx = new PgliteTransaction(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 (err) {
+			await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw err;
+		}
+	}
+};
+var PgliteDriver = class {
+	constructor(client, dialect, options = {}) {
+		this.client = client;
+		this.dialect = dialect;
+		this.options = options;
+	}
+	static [entityKind] = "PgliteDriver";
+	createSession(schema) {
+		return new PgliteSession(this.client, this.dialect, schema, {
+			logger: this.options.logger,
+			cache: this.options.cache
+		});
+	}
+};
+var PgliteDatabase = class extends PgDatabase {
+	static [entityKind] = "PgliteDatabase";
+};
+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 PgliteDatabase(dialect, new PgliteDriver(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 (params[0] === void 0 || typeof params[0] === "string") return construct(new Xe(params[0]), params[1]);
+	if (isConfig(params[0])) {
+		const { connection, client, ...drizzleConfig } = params[0];
+		if (client) return construct(client, drizzleConfig);
+		if (typeof connection === "object") {
+			const { dataDir, ...options } = connection;
+			return construct(new Xe(dataDir, options), drizzleConfig);
+		}
+		return construct(new Xe(connection), drizzleConfig);
+	}
+	return construct(params[0], params[1]);
+}
+((drizzle2) => {
+	function mock(config) {
+		return construct({}, config);
+	}
+	drizzle2.mock = mock;
+})(drizzle || (drizzle = {}));
+//#endregion
+export { drizzle as t };

package/dist/pglite-DMWgTUE6-BOIRUWUT.js

@@ -0,0 +1,2 @@
+import { t as drizzle } from "./pglite-CPs4w-D9-DHOg0D8W.js";
+export { drizzle };

package/dist/planetscale-serverless-DUMheN-f-Dyc_W6V_.js

@@ -0,0 +1,172 @@
+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, 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 { Client } from "@planetscale/database";
+//#region ../db/dist/planetscale-serverless-DUMheN-f.js
+var PlanetScalePreparedQuery = class extends MySqlPreparedQuery {
+	constructor(client, queryString, params, logger, cache, queryMetadata, cacheConfig, fields, customResultMapper, generatedIds, returningIds) {
+		super(cache, queryMetadata, cacheConfig);
+		this.client = client;
+		this.queryString = queryString;
+		this.params = params;
+		this.logger = logger;
+		this.fields = fields;
+		this.customResultMapper = customResultMapper;
+		this.generatedIds = generatedIds;
+		this.returningIds = returningIds;
+	}
+	static [entityKind] = "PlanetScalePreparedQuery";
+	rawQuery = { as: "object" };
+	query = { as: "array" };
+	async execute(placeholderValues = {}) {
+		const params = fillPlaceholders(this.params, placeholderValues);
+		this.logger.logQuery(this.queryString, params);
+		const { fields, client, queryString, rawQuery, query, joinsNotNullableMap, customResultMapper, returningIds, generatedIds } = this;
+		if (!fields && !customResultMapper) {
+			const res = await this.queryWithCache(queryString, params, async () => {
+				return await client.execute(queryString, params, rawQuery);
+			});
+			const insertId = Number.parseFloat(res.insertId);
+			const affectedRows = res.rowsAffected;
+			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(queryString, params, async () => {
+			return await client.execute(queryString, params, query);
+		});
+		if (customResultMapper) return customResultMapper(rows);
+		return rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
+	}
+	iterator(_placeholderValues) {
+		throw new Error("Streaming is not supported by the PlanetScale Serverless driver");
+	}
+};
+var PlanetscaleSession = class PlanetscaleSession extends MySqlSession {
+	constructor(baseClient, dialect, tx, schema, options = {}) {
+		super(dialect);
+		this.baseClient = baseClient;
+		this.schema = schema;
+		this.options = options;
+		this.client = tx ?? baseClient;
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+	}
+	static [entityKind] = "PlanetscaleSession";
+	logger;
+	client;
+	cache;
+	prepareQuery(query, fields, customResultMapper, generatedIds, returningIds, queryMetadata, cacheConfig) {
+		return new PlanetScalePreparedQuery(this.client, query.sql, query.params, this.logger, this.cache, queryMetadata, cacheConfig, fields, customResultMapper, generatedIds, returningIds);
+	}
+	async query(query, params) {
+		this.logger.logQuery(query, params);
+		return await this.client.execute(query, params, { as: "array" });
+	}
+	async queryObjects(query, params) {
+		return this.client.execute(query, params, { as: "object" });
+	}
+	all(query) {
+		const querySql = this.dialect.sqlToQuery(query);
+		this.logger.logQuery(querySql.sql, querySql.params);
+		return this.client.execute(querySql.sql, querySql.params, { as: "object" }).then((eQuery) => eQuery.rows);
+	}
+	async count(sql2) {
+		const res = await this.execute(sql2);
+		return Number(res["rows"][0]["count"]);
+	}
+	transaction(transaction) {
+		return this.baseClient.transaction((pstx) => {
+			const session = new PlanetscaleSession(this.baseClient, this.dialect, pstx, this.schema, this.options);
+			return transaction(new PlanetScaleTransaction(this.dialect, session, this.schema));
+		});
+	}
+};
+var PlanetScaleTransaction = class PlanetScaleTransaction extends MySqlTransaction {
+	static [entityKind] = "PlanetScaleTransaction";
+	constructor(dialect, session, schema, nestedIndex = 0) {
+		super(dialect, session, schema, nestedIndex, "planetscale");
+	}
+	async transaction(transaction) {
+		const savepointName = `sp${this.nestedIndex + 1}`;
+		const tx = new PlanetScaleTransaction(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 (err) {
+			await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw err;
+		}
+	}
+};
+var PlanetScaleDatabase = class extends MySqlDatabase {
+	static [entityKind] = "PlanetScaleDatabase";
+};
+function construct(client, config = {}) {
+	if (!(client instanceof Client)) throw new Error(`Warning: You need to pass an instance of Client:
+
+import { Client } from "@planetscale/database";
+
+const client = new Client({
+  host: process.env["DATABASE_HOST"],
+  username: process.env["DATABASE_USERNAME"],
+  password: process.env["DATABASE_PASSWORD"],
+});
+
+const db = drizzle(client);
+		`);
+	const dialect = new MySqlDialect({ 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 PlanetScaleDatabase(dialect, new PlanetscaleSession(client, dialect, void 0, schema, {
+		logger,
+		cache: config.cache
+	}), schema, "planetscale");
+	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 Client({ url: params[0] }), params[1]);
+	if (isConfig(params[0])) {
+		const { connection, client, ...drizzleConfig } = params[0];
+		if (client) return construct(client, drizzleConfig);
+		return construct(typeof connection === "string" ? new Client({ url: connection }) : new Client(connection), drizzleConfig);
+	}
+	return construct(params[0], params[1]);
+}
+((drizzle2) => {
+	function mock(config) {
+		return construct({}, config);
+	}
+	drizzle2.mock = mock;
+})(drizzle || (drizzle = {}));
+//#endregion
+export { drizzle };