azure-mock 2.20.0 → 2.22.0

package/dist/sqlite-proxy-BgUfVEbZ-CsSkc-_K.js

@@ -0,0 +1,190 @@
+import { C as sql, _ as fillPlaceholders, g as entityKind } from "./sql-CNZp2yLp-Bwugq384.js";
+import { M as mapResultRow, n as DefaultLogger, o as NoopCache, s as NoopLogger, x as extractTablesRelationalConfig, y as createTableRelationsHelpers } from "./logger-TIsK7375-CLNNa25D.js";
+import { n as SQLiteAsyncDialect } from "./query-builder-CT3_liD0-hhg5kRTk.js";
+import { i as SQLiteTransaction, n as SQLitePreparedQuery, r as SQLiteSession, t as BaseSQLiteDatabase } from "./session-Cjeygn2Z-BO0mi6pq.js";
+//#region ../db/dist/sqlite-proxy-BgUfVEbZ.js
+var SQLiteRemoteSession = class extends SQLiteSession {
+	constructor(client, dialect, schema, batchCLient, options = {}) {
+		super(dialect);
+		this.client = client;
+		this.schema = schema;
+		this.batchCLient = batchCLient;
+		this.logger = options.logger ?? new NoopLogger();
+		this.cache = options.cache ?? new NoopCache();
+	}
+	static [entityKind] = "SQLiteRemoteSession";
+	logger;
+	cache;
+	prepareQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
+		return new RemotePreparedQuery(this.client, query, this.logger, this.cache, queryMetadata, cacheConfig, fields, executeMethod, isResponseInArrayMode, customResultMapper);
+	}
+	async batch(queries) {
+		const preparedQueries = [];
+		const builtQueries = [];
+		for (const query of queries) {
+			const preparedQuery = query._prepare();
+			const builtQuery = preparedQuery.getQuery();
+			preparedQueries.push(preparedQuery);
+			builtQueries.push({
+				sql: builtQuery.sql,
+				params: builtQuery.params,
+				method: builtQuery.method
+			});
+		}
+		return (await this.batchCLient(builtQueries)).map((result, i) => preparedQueries[i].mapResult(result, true));
+	}
+	async transaction(transaction, config) {
+		const tx = new SQLiteProxyTransaction("async", this.dialect, this, this.schema);
+		await this.run(sql.raw(`begin${config?.behavior ? " " + config.behavior : ""}`));
+		try {
+			const result = await transaction(tx);
+			await this.run(sql`commit`);
+			return result;
+		} catch (err) {
+			await this.run(sql`rollback`);
+			throw err;
+		}
+	}
+	extractRawAllValueFromBatchResult(result) {
+		return result.rows;
+	}
+	extractRawGetValueFromBatchResult(result) {
+		return result.rows[0];
+	}
+	extractRawValuesValueFromBatchResult(result) {
+		return result.rows;
+	}
+};
+var SQLiteProxyTransaction = class SQLiteProxyTransaction extends SQLiteTransaction {
+	static [entityKind] = "SQLiteProxyTransaction";
+	async transaction(transaction) {
+		const savepointName = `sp${this.nestedIndex}`;
+		const tx = new SQLiteProxyTransaction("async", this.dialect, this.session, this.schema, this.nestedIndex + 1);
+		await this.session.run(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = await transaction(tx);
+			await this.session.run(sql.raw(`release savepoint ${savepointName}`));
+			return result;
+		} catch (err) {
+			await this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw err;
+		}
+	}
+};
+var RemotePreparedQuery = class extends SQLitePreparedQuery {
+	constructor(client, query, logger, cache, queryMetadata, cacheConfig, fields, executeMethod, _isResponseInArrayMode, customResultMapper) {
+		super("async", executeMethod, query, cache, queryMetadata, cacheConfig);
+		this.client = client;
+		this.logger = logger;
+		this.fields = fields;
+		this._isResponseInArrayMode = _isResponseInArrayMode;
+		this.customResultMapper = customResultMapper;
+		this.customResultMapper = customResultMapper;
+		this.method = executeMethod;
+	}
+	static [entityKind] = "SQLiteProxyPreparedQuery";
+	method;
+	getQuery() {
+		return {
+			...this.query,
+			method: this.method
+		};
+	}
+	async run(placeholderValues) {
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
+		return await this.queryWithCache(this.query.sql, params, async () => {
+			return await this.client(this.query.sql, params, "run");
+		});
+	}
+	mapAllResult(rows, isFromBatch) {
+		if (isFromBatch) rows = rows.rows;
+		if (!this.fields && !this.customResultMapper) return rows;
+		if (this.customResultMapper) return this.customResultMapper(rows);
+		return rows.map((row) => {
+			return mapResultRow(this.fields, row, this.joinsNotNullableMap);
+		});
+	}
+	async all(placeholderValues) {
+		const { query, logger, client } = this;
+		const params = fillPlaceholders(query.params, placeholderValues ?? {});
+		logger.logQuery(query.sql, params);
+		const { rows } = await this.queryWithCache(query.sql, params, async () => {
+			return await client(query.sql, params, "all");
+		});
+		return this.mapAllResult(rows);
+	}
+	async get(placeholderValues) {
+		const { query, logger, client } = this;
+		const params = fillPlaceholders(query.params, placeholderValues ?? {});
+		logger.logQuery(query.sql, params);
+		const clientResult = await this.queryWithCache(query.sql, params, async () => {
+			return await client(query.sql, params, "get");
+		});
+		return this.mapGetResult(clientResult.rows);
+	}
+	mapGetResult(rows, isFromBatch) {
+		if (isFromBatch) rows = rows.rows;
+		const row = rows;
+		if (!this.fields && !this.customResultMapper) return row;
+		if (!row) return;
+		if (this.customResultMapper) return this.customResultMapper([rows]);
+		return mapResultRow(this.fields, row, this.joinsNotNullableMap);
+	}
+	async values(placeholderValues) {
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
+		return (await this.queryWithCache(this.query.sql, params, async () => {
+			return await this.client(this.query.sql, params, "values");
+		})).rows;
+	}
+	/** @internal */
+	isResponseInArrayMode() {
+		return this._isResponseInArrayMode;
+	}
+};
+var SqliteRemoteDatabase = class extends BaseSQLiteDatabase {
+	static [entityKind] = "SqliteRemoteDatabase";
+	async batch(batch) {
+		return this.session.batch(batch);
+	}
+};
+function drizzle(callback, batchCallback, config) {
+	const dialect = new SQLiteAsyncDialect({ casing: config?.casing });
+	let logger;
+	let cache;
+	let _batchCallback;
+	let _config = {};
+	if (batchCallback) {
+		if (typeof batchCallback === "function") {
+			_batchCallback = batchCallback;
+			_config = config ?? {};
+		} else {
+			_batchCallback = void 0;
+			_config = batchCallback;
+		}
+		if (_config.logger === true) logger = new DefaultLogger();
+		else if (_config.logger !== false) {
+			logger = _config.logger;
+			cache = _config.cache;
+		}
+	}
+	let schema;
+	if (_config.schema) {
+		const tablesConfig = extractTablesRelationalConfig(_config.schema, createTableRelationsHelpers);
+		schema = {
+			fullSchema: _config.schema,
+			schema: tablesConfig.tables,
+			tableNamesMap: tablesConfig.tableNamesMap
+		};
+	}
+	const db = new SqliteRemoteDatabase("async", dialect, new SQLiteRemoteSession(callback, dialect, schema, _batchCallback, {
+		logger,
+		cache
+	}), schema);
+	db.$cache = cache;
+	if (db.$cache) db.$cache["invalidate"] = cache?.onMutate;
+	return db;
+}
+//#endregion
+export { drizzle };