azure-mock 2.22.0 → 2.24.0

package/dist/logger-TIsK7375-CLNNa25D.js

@@ -1,652 +0,0 @@
-import { C as sql, S as isSQLWrapper, b as is, d as Table, g as entityKind, l as StringChunk, m as ViewBaseConfig, o as Placeholder, p as View, r as Param, s as SQL, t as Column, u as Subquery, v as getTableName, x as isDriverValueEncoder, y as getTableUniqueName } from "./sql-CNZp2yLp-Bwugq384.js";
-//#region ../db/dist/logger-TIsK7375.js
-function toSnakeCase(input) {
-	return (input.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? []).map((word) => word.toLowerCase()).join("_");
-}
-function toCamelCase(input) {
-	return (input.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? []).reduce((acc, word, i) => {
-		return acc + (i === 0 ? word.toLowerCase() : `${word[0].toUpperCase()}${word.slice(1)}`);
-	}, "");
-}
-function noopCase(input) {
-	return input;
-}
-var CasingCache = class {
-	static [entityKind] = "CasingCache";
-	/** @internal */
-	cache = {};
-	cachedTables = {};
-	convert;
-	constructor(casing) {
-		this.convert = casing === "snake_case" ? toSnakeCase : casing === "camelCase" ? toCamelCase : noopCase;
-	}
-	getColumnCasing(column) {
-		if (!column.keyAsName) return column.name;
-		const key = `${column.table[Table.Symbol.Schema] ?? "public"}.${column.table[Table.Symbol.OriginalName]}.${column.name}`;
-		if (!this.cache[key]) this.cacheTable(column.table);
-		return this.cache[key];
-	}
-	cacheTable(table) {
-		const tableKey = `${table[Table.Symbol.Schema] ?? "public"}.${table[Table.Symbol.OriginalName]}`;
-		if (!this.cachedTables[tableKey]) {
-			for (const column of Object.values(table[Table.Symbol.Columns])) {
-				const columnKey = `${tableKey}.${column.name}`;
-				this.cache[columnKey] = this.convert(column.name);
-			}
-			this.cachedTables[tableKey] = true;
-		}
-	}
-	clearCache() {
-		this.cache = {};
-		this.cachedTables = {};
-	}
-};
-var ColumnAliasProxyHandler = class {
-	constructor(table) {
-		this.table = table;
-	}
-	static [entityKind] = "ColumnAliasProxyHandler";
-	get(columnObj, prop) {
-		if (prop === "table") return this.table;
-		return columnObj[prop];
-	}
-};
-var TableAliasProxyHandler = class {
-	constructor(alias, replaceOriginalName) {
-		this.alias = alias;
-		this.replaceOriginalName = replaceOriginalName;
-	}
-	static [entityKind] = "TableAliasProxyHandler";
-	get(target, prop) {
-		if (prop === Table.Symbol.IsAlias) return true;
-		if (prop === Table.Symbol.Name) return this.alias;
-		if (this.replaceOriginalName && prop === Table.Symbol.OriginalName) return this.alias;
-		if (prop === ViewBaseConfig) return {
-			...target[ViewBaseConfig],
-			name: this.alias,
-			isAlias: true
-		};
-		if (prop === Table.Symbol.Columns) {
-			const columns = target[Table.Symbol.Columns];
-			if (!columns) return columns;
-			const proxiedColumns = {};
-			Object.keys(columns).map((key) => {
-				proxiedColumns[key] = new Proxy(columns[key], new ColumnAliasProxyHandler(new Proxy(target, this)));
-			});
-			return proxiedColumns;
-		}
-		const value = target[prop];
-		if (is(value, Column)) return new Proxy(value, new ColumnAliasProxyHandler(new Proxy(target, this)));
-		return value;
-	}
-};
-function aliasedTable(table, tableAlias) {
-	return new Proxy(table, new TableAliasProxyHandler(tableAlias, false));
-}
-function aliasedTableColumn(column, tableAlias) {
-	return new Proxy(column, new ColumnAliasProxyHandler(new Proxy(column.table, new TableAliasProxyHandler(tableAlias, false))));
-}
-function mapColumnsInAliasedSQLToAlias(query, alias) {
-	return new SQL.Aliased(mapColumnsInSQLToAlias(query.sql, alias), query.fieldAlias);
-}
-function mapColumnsInSQLToAlias(query, alias) {
-	return sql.join(query.queryChunks.map((c) => {
-		if (is(c, Column)) return aliasedTableColumn(c, alias);
-		if (is(c, SQL)) return mapColumnsInSQLToAlias(c, alias);
-		if (is(c, SQL.Aliased)) return mapColumnsInAliasedSQLToAlias(c, alias);
-		return c;
-	}));
-}
-function mapResultRow(columns, row, joinsNotNullableMap) {
-	const nullifyMap = {};
-	const result = columns.reduce((result2, { path, field }, columnIndex) => {
-		let decoder;
-		if (is(field, Column)) decoder = field;
-		else if (is(field, SQL)) decoder = field.decoder;
-		else if (is(field, Subquery)) decoder = field._.sql.decoder;
-		else decoder = field.sql.decoder;
-		let node = result2;
-		for (const [pathChunkIndex, pathChunk] of path.entries()) if (pathChunkIndex < path.length - 1) {
-			if (!(pathChunk in node)) node[pathChunk] = {};
-			node = node[pathChunk];
-		} else {
-			const rawValue = row[columnIndex];
-			const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-			if (joinsNotNullableMap && is(field, Column) && path.length === 2) {
-				const objectName = path[0];
-				if (!(objectName in nullifyMap)) nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
-				else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) nullifyMap[objectName] = false;
-			}
-		}
-		return result2;
-	}, {});
-	if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
-		for (const [objectName, tableName] of Object.entries(nullifyMap)) if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) result[objectName] = null;
-	}
-	return result;
-}
-function orderSelectedFields(fields, pathPrefix) {
-	return Object.entries(fields).reduce((result, [name, field]) => {
-		if (typeof name !== "string") return result;
-		const newPath = pathPrefix ? [...pathPrefix, name] : [name];
-		if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased) || is(field, Subquery)) result.push({
-			path: newPath,
-			field
-		});
-		else if (is(field, Table)) result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));
-		else result.push(...orderSelectedFields(field, newPath));
-		return result;
-	}, []);
-}
-function haveSameKeys(left, right) {
-	const leftKeys = Object.keys(left);
-	const rightKeys = Object.keys(right);
-	if (leftKeys.length !== rightKeys.length) return false;
-	for (const [index, key] of leftKeys.entries()) if (key !== rightKeys[index]) return false;
-	return true;
-}
-function mapUpdateSet(table, values) {
-	const entries = Object.entries(values).filter(([, value]) => value !== void 0).map(([key, value]) => {
-		if (is(value, SQL) || is(value, Column)) return [key, value];
-		else return [key, new Param(value, table[Table.Symbol.Columns][key])];
-	});
-	if (entries.length === 0) throw new Error("No values to set");
-	return Object.fromEntries(entries);
-}
-function applyMixins(baseClass, extendedClasses) {
-	for (const extendedClass of extendedClasses) for (const name of Object.getOwnPropertyNames(extendedClass.prototype)) {
-		if (name === "constructor") continue;
-		Object.defineProperty(baseClass.prototype, name, Object.getOwnPropertyDescriptor(extendedClass.prototype, name) || /* @__PURE__ */ Object.create(null));
-	}
-}
-function getTableColumns(table) {
-	return table[Table.Symbol.Columns];
-}
-function getTableLikeName(table) {
-	return is(table, Subquery) ? table._.alias : is(table, View) ? table[ViewBaseConfig].name : is(table, SQL) ? void 0 : table[Table.Symbol.IsAlias] ? table[Table.Symbol.Name] : table[Table.Symbol.BaseName];
-}
-function isConfig(data) {
-	if (typeof data !== "object" || data === null) return false;
-	if (data.constructor.name !== "Object") return false;
-	if ("logger" in data) {
-		const type = typeof data["logger"];
-		if (type !== "boolean" && (type !== "object" || typeof data["logger"]["logQuery"] !== "function") && type !== "undefined") return false;
-		return true;
-	}
-	if ("schema" in data) {
-		const type = typeof data["schema"];
-		if (type !== "object" && type !== "undefined") return false;
-		return true;
-	}
-	if ("casing" in data) {
-		const type = typeof data["casing"];
-		if (type !== "string" && type !== "undefined") return false;
-		return true;
-	}
-	if ("mode" in data) {
-		if (data["mode"] !== "default" || data["mode"] !== "planetscale" || data["mode"] !== void 0) return false;
-		return true;
-	}
-	if ("connection" in data) {
-		const type = typeof data["connection"];
-		if (type !== "string" && type !== "object" && type !== "undefined") return false;
-		return true;
-	}
-	if ("client" in data) {
-		const type = typeof data["client"];
-		if (type !== "object" && type !== "function" && type !== "undefined") return false;
-		return true;
-	}
-	if (Object.keys(data).length === 0) return true;
-	return false;
-}
-typeof TextDecoder === "undefined" || new TextDecoder();
-var SelectionProxyHandler = class SelectionProxyHandler {
-	static [entityKind] = "SelectionProxyHandler";
-	config;
-	constructor(config) {
-		this.config = { ...config };
-	}
-	get(subquery, prop) {
-		if (prop === "_") return {
-			...subquery["_"],
-			selectedFields: new Proxy(subquery._.selectedFields, this)
-		};
-		if (prop === ViewBaseConfig) return {
-			...subquery[ViewBaseConfig],
-			selectedFields: new Proxy(subquery[ViewBaseConfig].selectedFields, this)
-		};
-		if (typeof prop === "symbol") return subquery[prop];
-		const value = (is(subquery, Subquery) ? subquery._.selectedFields : is(subquery, View) ? subquery[ViewBaseConfig].selectedFields : subquery)[prop];
-		if (is(value, SQL.Aliased)) {
-			if (this.config.sqlAliasedBehavior === "sql" && !value.isSelectionField) return value.sql;
-			const newValue = value.clone();
-			newValue.isSelectionField = true;
-			return newValue;
-		}
-		if (is(value, SQL)) {
-			if (this.config.sqlBehavior === "sql") return value;
-			throw new Error(`You tried to reference "${prop}" field from a subquery, which is a raw SQL field, but it doesn't have an alias declared. Please add an alias to the field using ".as('alias')" method.`);
-		}
-		if (is(value, Column)) {
-			if (this.config.alias) return new Proxy(value, new ColumnAliasProxyHandler(new Proxy(value.table, new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false))));
-			return value;
-		}
-		if (typeof value !== "object" || value === null) return value;
-		return new Proxy(value, new SelectionProxyHandler(this.config));
-	}
-};
-var QueryPromise = class {
-	static [entityKind] = "QueryPromise";
-	[Symbol.toStringTag] = "QueryPromise";
-	catch(onRejected) {
-		return this.then(void 0, onRejected);
-	}
-	finally(onFinally) {
-		return this.then((value) => {
-			onFinally?.();
-			return value;
-		}, (reason) => {
-			onFinally?.();
-			throw reason;
-		});
-	}
-	then(onFulfilled, onRejected) {
-		return this.execute().then(onFulfilled, onRejected);
-	}
-};
-var DrizzleError = class extends Error {
-	static [entityKind] = "DrizzleError";
-	constructor({ message, cause }) {
-		super(message);
-		this.name = "DrizzleError";
-		this.cause = cause;
-	}
-};
-var DrizzleQueryError = class DrizzleQueryError extends Error {
-	constructor(query, params, cause) {
-		super(`Failed query: ${query}
-params: ${params}`);
-		this.query = query;
-		this.params = params;
-		this.cause = cause;
-		Error.captureStackTrace(this, DrizzleQueryError);
-		if (cause) this.cause = cause;
-	}
-};
-var TransactionRollbackError = class extends DrizzleError {
-	static [entityKind] = "TransactionRollbackError";
-	constructor() {
-		super({ message: "Rollback" });
-	}
-};
-const InlineForeignKeys = Symbol.for("drizzle:PgInlineForeignKeys");
-const EnableRLS = Symbol.for("drizzle:EnableRLS");
-var PgTable = class extends Table {
-	static [entityKind] = "PgTable";
-	/** @internal */
-	static Symbol = Object.assign({}, Table.Symbol, {
-		InlineForeignKeys,
-		EnableRLS
-	});
-	/**@internal */
-	[InlineForeignKeys] = [];
-	/** @internal */
-	[EnableRLS] = false;
-	/** @internal */
-	[Table.Symbol.ExtraConfigBuilder] = void 0;
-	/** @internal */
-	[Table.Symbol.ExtraConfigColumns] = {};
-};
-var PrimaryKeyBuilder = class {
-	static [entityKind] = "PgPrimaryKeyBuilder";
-	/** @internal */
-	columns;
-	/** @internal */
-	name;
-	constructor(columns, name) {
-		this.columns = columns;
-		this.name = name;
-	}
-	/** @internal */
-	build(table) {
-		return new PrimaryKey(table, this.columns, this.name);
-	}
-};
-var PrimaryKey = class {
-	constructor(table, columns, name) {
-		this.table = table;
-		this.columns = columns;
-		this.name = name;
-	}
-	static [entityKind] = "PgPrimaryKey";
-	columns;
-	name;
-	getName() {
-		return this.name ?? `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
-	}
-};
-function bindIfParam(value, column) {
-	if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) return new Param(value, column);
-	return value;
-}
-const eq = (left, right) => {
-	return sql`${left} = ${bindIfParam(right, left)}`;
-};
-const ne = (left, right) => {
-	return sql`${left} <> ${bindIfParam(right, left)}`;
-};
-function and(...unfilteredConditions) {
-	const conditions = unfilteredConditions.filter((c) => c !== void 0);
-	if (conditions.length === 0) return;
-	if (conditions.length === 1) return new SQL(conditions);
-	return new SQL([
-		new StringChunk("("),
-		sql.join(conditions, new StringChunk(" and ")),
-		new StringChunk(")")
-	]);
-}
-function or(...unfilteredConditions) {
-	const conditions = unfilteredConditions.filter((c) => c !== void 0);
-	if (conditions.length === 0) return;
-	if (conditions.length === 1) return new SQL(conditions);
-	return new SQL([
-		new StringChunk("("),
-		sql.join(conditions, new StringChunk(" or ")),
-		new StringChunk(")")
-	]);
-}
-function not(condition) {
-	return sql`not ${condition}`;
-}
-const gt = (left, right) => {
-	return sql`${left} > ${bindIfParam(right, left)}`;
-};
-const gte = (left, right) => {
-	return sql`${left} >= ${bindIfParam(right, left)}`;
-};
-const lt = (left, right) => {
-	return sql`${left} < ${bindIfParam(right, left)}`;
-};
-const lte = (left, right) => {
-	return sql`${left} <= ${bindIfParam(right, left)}`;
-};
-function inArray(column, values) {
-	if (Array.isArray(values)) {
-		if (values.length === 0) return sql`false`;
-		return sql`${column} in ${values.map((v) => bindIfParam(v, column))}`;
-	}
-	return sql`${column} in ${bindIfParam(values, column)}`;
-}
-function notInArray(column, values) {
-	if (Array.isArray(values)) {
-		if (values.length === 0) return sql`true`;
-		return sql`${column} not in ${values.map((v) => bindIfParam(v, column))}`;
-	}
-	return sql`${column} not in ${bindIfParam(values, column)}`;
-}
-function isNull(value) {
-	return sql`${value} is null`;
-}
-function isNotNull(value) {
-	return sql`${value} is not null`;
-}
-function exists(subquery) {
-	return sql`exists ${subquery}`;
-}
-function notExists(subquery) {
-	return sql`not exists ${subquery}`;
-}
-function between(column, min, max) {
-	return sql`${column} between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
-}
-function notBetween(column, min, max) {
-	return sql`${column} not between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
-}
-function like(column, value) {
-	return sql`${column} like ${value}`;
-}
-function notLike(column, value) {
-	return sql`${column} not like ${value}`;
-}
-function ilike(column, value) {
-	return sql`${column} ilike ${value}`;
-}
-function notIlike(column, value) {
-	return sql`${column} not ilike ${value}`;
-}
-function asc(column) {
-	return sql`${column} asc`;
-}
-function desc(column) {
-	return sql`${column} desc`;
-}
-var Relation = class {
-	constructor(sourceTable, referencedTable, relationName) {
-		this.sourceTable = sourceTable;
-		this.referencedTable = referencedTable;
-		this.relationName = relationName;
-		this.referencedTableName = referencedTable[Table.Symbol.Name];
-	}
-	static [entityKind] = "Relation";
-	referencedTableName;
-	fieldName;
-};
-var Relations = class {
-	constructor(table, config) {
-		this.table = table;
-		this.config = config;
-	}
-	static [entityKind] = "Relations";
-};
-var One = class One extends Relation {
-	constructor(sourceTable, referencedTable, config, isNullable) {
-		super(sourceTable, referencedTable, config?.relationName);
-		this.config = config;
-		this.isNullable = isNullable;
-	}
-	static [entityKind] = "One";
-	withFieldName(fieldName) {
-		const relation = new One(this.sourceTable, this.referencedTable, this.config, this.isNullable);
-		relation.fieldName = fieldName;
-		return relation;
-	}
-};
-var Many = class Many extends Relation {
-	constructor(sourceTable, referencedTable, config) {
-		super(sourceTable, referencedTable, config?.relationName);
-		this.config = config;
-	}
-	static [entityKind] = "Many";
-	withFieldName(fieldName) {
-		const relation = new Many(this.sourceTable, this.referencedTable, this.config);
-		relation.fieldName = fieldName;
-		return relation;
-	}
-};
-function getOperators() {
-	return {
-		and,
-		between,
-		eq,
-		exists,
-		gt,
-		gte,
-		ilike,
-		inArray,
-		isNull,
-		isNotNull,
-		like,
-		lt,
-		lte,
-		ne,
-		not,
-		notBetween,
-		notExists,
-		notLike,
-		notIlike,
-		notInArray,
-		or,
-		sql
-	};
-}
-function getOrderByOperators() {
-	return {
-		sql,
-		asc,
-		desc
-	};
-}
-function extractTablesRelationalConfig(schema, configHelpers) {
-	if (Object.keys(schema).length === 1 && "default" in schema && !is(schema["default"], Table)) schema = schema["default"];
-	const tableNamesMap = {};
-	const relationsBuffer = {};
-	const tablesConfig = {};
-	for (const [key, value] of Object.entries(schema)) if (is(value, Table)) {
-		const dbName = getTableUniqueName(value);
-		const bufferedRelations = relationsBuffer[dbName];
-		tableNamesMap[dbName] = key;
-		tablesConfig[key] = {
-			tsName: key,
-			dbName: value[Table.Symbol.Name],
-			schema: value[Table.Symbol.Schema],
-			columns: value[Table.Symbol.Columns],
-			relations: bufferedRelations?.relations ?? {},
-			primaryKey: bufferedRelations?.primaryKey ?? []
-		};
-		for (const column of Object.values(value[Table.Symbol.Columns])) if (column.primary) tablesConfig[key].primaryKey.push(column);
-		const extraConfig = value[Table.Symbol.ExtraConfigBuilder]?.(value[Table.Symbol.ExtraConfigColumns]);
-		if (extraConfig) {
-			for (const configEntry of Object.values(extraConfig)) if (is(configEntry, PrimaryKeyBuilder)) tablesConfig[key].primaryKey.push(...configEntry.columns);
-		}
-	} else if (is(value, Relations)) {
-		const dbName = getTableUniqueName(value.table);
-		const tableName = tableNamesMap[dbName];
-		const relations2 = value.config(configHelpers(value.table));
-		let primaryKey;
-		for (const [relationName, relation] of Object.entries(relations2)) if (tableName) {
-			const tableConfig = tablesConfig[tableName];
-			tableConfig.relations[relationName] = relation;
-		} else {
-			if (!(dbName in relationsBuffer)) relationsBuffer[dbName] = {
-				relations: {},
-				primaryKey
-			};
-			relationsBuffer[dbName].relations[relationName] = relation;
-		}
-	}
-	return {
-		tables: tablesConfig,
-		tableNamesMap
-	};
-}
-function createOne(sourceTable) {
-	return function one(table, config) {
-		return new One(sourceTable, table, config, config?.fields.reduce((res, f) => res && f.notNull, true) ?? false);
-	};
-}
-function createMany(sourceTable) {
-	return function many(referencedTable, config) {
-		return new Many(sourceTable, referencedTable, config);
-	};
-}
-function normalizeRelation(schema, tableNamesMap, relation) {
-	if (is(relation, One) && relation.config) return {
-		fields: relation.config.fields,
-		references: relation.config.references
-	};
-	const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
-	if (!referencedTableTsName) throw new Error(`Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`);
-	const referencedTableConfig = schema[referencedTableTsName];
-	if (!referencedTableConfig) throw new Error(`Table "${referencedTableTsName}" not found in schema`);
-	const sourceTable = relation.sourceTable;
-	const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];
-	if (!sourceTableTsName) throw new Error(`Table "${sourceTable[Table.Symbol.Name]}" not found in schema`);
-	const reverseRelations = [];
-	for (const referencedTableRelation of Object.values(referencedTableConfig.relations)) if (relation.relationName && relation !== referencedTableRelation && referencedTableRelation.relationName === relation.relationName || !relation.relationName && referencedTableRelation.referencedTable === relation.sourceTable) reverseRelations.push(referencedTableRelation);
-	if (reverseRelations.length > 1) throw relation.relationName ? /* @__PURE__ */ new Error(`There are multiple relations with name "${relation.relationName}" in table "${referencedTableTsName}"`) : /* @__PURE__ */ new Error(`There are multiple relations between "${referencedTableTsName}" and "${relation.sourceTable[Table.Symbol.Name]}". Please specify relation name`);
-	if (reverseRelations[0] && is(reverseRelations[0], One) && reverseRelations[0].config) return {
-		fields: reverseRelations[0].config.references,
-		references: reverseRelations[0].config.fields
-	};
-	throw new Error(`There is not enough information to infer relation "${sourceTableTsName}.${relation.fieldName}"`);
-}
-function createTableRelationsHelpers(sourceTable) {
-	return {
-		one: createOne(sourceTable),
-		many: createMany(sourceTable)
-	};
-}
-function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelection, mapColumnValue = (value) => value) {
-	const result = {};
-	for (const [selectionItemIndex, selectionItem] of buildQueryResultSelection.entries()) if (selectionItem.isJson) {
-		const relation = tableConfig.relations[selectionItem.tsKey];
-		const rawSubRows = row[selectionItemIndex];
-		const subRows = typeof rawSubRows === "string" ? JSON.parse(rawSubRows) : rawSubRows;
-		result[selectionItem.tsKey] = is(relation, One) ? subRows && mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRows, selectionItem.selection, mapColumnValue) : subRows.map((subRow) => mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRow, selectionItem.selection, mapColumnValue));
-	} else {
-		const value = mapColumnValue(row[selectionItemIndex]);
-		const field = selectionItem.field;
-		let decoder;
-		if (is(field, Column)) decoder = field;
-		else if (is(field, SQL)) decoder = field.decoder;
-		else decoder = field.sql.decoder;
-		result[selectionItem.tsKey] = value === null ? null : decoder.mapFromDriverValue(value);
-	}
-	return result;
-}
-var TypedQueryBuilder = class {
-	static [entityKind] = "TypedQueryBuilder";
-	/** @internal */
-	getSelectedFields() {
-		return this._.selectedFields;
-	}
-};
-var Cache = class {
-	static [entityKind] = "Cache";
-};
-var NoopCache = class extends Cache {
-	strategy() {
-		return "all";
-	}
-	static [entityKind] = "NoopCache";
-	async get(_key) {}
-	async put(_hashedQuery, _response, _tables, _config) {}
-	async onMutate(_params) {}
-};
-async function hashQuery(sql, params) {
-	const dataToHash = `${sql}-${JSON.stringify(params)}`;
-	const data = new TextEncoder().encode(dataToHash);
-	const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-	return [...new Uint8Array(hashBuffer)].map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-var ConsoleLogWriter = class {
-	static [entityKind] = "ConsoleLogWriter";
-	write(message) {
-		console.log(message);
-	}
-};
-var DefaultLogger = class {
-	static [entityKind] = "DefaultLogger";
-	writer;
-	constructor(config) {
-		this.writer = config?.writer ?? new ConsoleLogWriter();
-	}
-	logQuery(query, params) {
-		const stringifiedParams = params.map((p) => {
-			try {
-				return JSON.stringify(p);
-			} catch {
-				return String(p);
-			}
-		});
-		const paramsStr = stringifiedParams.length ? ` -- params: [${stringifiedParams.join(", ")}]` : "";
-		this.writer.write(`Query: ${query}${paramsStr}`);
-	}
-};
-var NoopLogger = class {
-	static [entityKind] = "NoopLogger";
-	logQuery() {}
-};
-//#endregion
-export { mapColumnsInSQLToAlias as A, getOrderByOperators as C, haveSameKeys as D, hashQuery as E, orderSelectedFields as F, toCamelCase as I, toSnakeCase as L, mapResultRow as M, mapUpdateSet as N, isConfig as O, normalizeRelation as P, getOperators as S, getTableLikeName as T, and as _, Many as a, eq as b, One as c, Relations as d, SelectionProxyHandler as f, aliasedTableColumn as g, aliasedTable as h, DrizzleQueryError as i, mapRelationalRow as j, mapColumnsInAliasedSQLToAlias as k, PgTable as l, TypedQueryBuilder as m, DefaultLogger as n, NoopCache as o, TransactionRollbackError as p, DrizzleError as r, NoopLogger as s, CasingCache as t, QueryPromise as u, applyMixins as v, getTableColumns as w, extractTablesRelationalConfig as x, createTableRelationsHelpers as y };

package/dist/migrator-B9kYwLqO-4g9JX3_v.js

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

package/dist/migrator-BfTfJctM-DrNlb1BS.js

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

package/dist/migrator-BjoW0_3j-CD-XdZ5a.js

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

package/dist/migrator-CWWlo_Jk-C4Hw4PPN.js

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