@typed-sql/mysql 1.0.0-rc.0 → 2.0.0-rc.1

package/dist/packages/mysql/src/runtime.js

@@ -1,118 +1,578 @@
 var _a;
-import { renderQuery } from "@typed-sql/core";
+import { createHash } from "node:crypto";
+import { adapterCapabilities, assertExecutionCapabilities, createAdapterCapabilityResolver, databaseErrorCompletion, hasQueryResultValidator, observeQueryStream, QueryCardinalityError, queryResultValidationSource, renderQuery, runControlledExecution, startDatabaseObservation, UnsupportedExecutionCapabilityError, validateQueryResultRows, validateQueryResultStream, } from "@typed-sql/core";
+import { createMySqlBulkCapability, mysqlBulk } from "./bulk.js";
+import { decodeMySqlRows, encodeMySqlValue, MySqlDecoderPlanCache, } from "./decoding.js";
+import { createMySqlPreparedQueryState, prepareMySqlQuery, } from "./prepared.js";
+import { createMySqlQueryStream, validateMySqlStreamBatchSize } from "./stream.js";
 import { defaultMySqlTypePolicy } from "./type-policy.js";
-const defaultRuntimePolicy = defaultMySqlTypePolicy;
-const mysqlTypes = { tiny: 1, longlong: 8, date: 10, datetime: 12, timestamp: 7, json: 245, decimal: 246 };
+import { MYSQL_DIALECT_VERSION } from "./version.js";
+const defaultRuntimeTypePolicy = defaultMySqlTypePolicy;
+const emptyBatchResults = Object.freeze([]);
+function createMySqlObservationState(observer) {
+    return { observer, fingerprints: observer === undefined ? undefined : new WeakMap() };
+}
+function mysqlQueryFingerprint(state, query) {
+    const key = query;
+    const cached = state.fingerprints?.get(key);
+    if (cached !== undefined)
+        return cached;
+    const text = renderQuery(query, mysqlRenderer).text;
+    const fingerprint = `sha256:${createHash("sha256").update(`mysql\0${MYSQL_DIALECT_VERSION}\0${text}`).digest("hex")}`;
+    state.fingerprints?.set(key, fingerprint);
+    return fingerprint;
+}
 export const mysqlRenderer = Object.freeze({
     placeholder: () => "?",
     quoteIdentifier: (identifier) => `\`${identifier.replaceAll("`", "``")}\``,
 });
-function encoded(value) {
-    return typeof value === "bigint" ? value.toString() : Array.isArray(value) ? value.map(encoded) : value;
-}
-function finite(value, label) {
-    const result = Number(value);
-    if (!Number.isFinite(result))
-        throw new RangeError(`${label} value ${value} cannot be represented as a finite number`);
-    return result;
-}
-function decode(value, field, policy, decimal) {
-    if (value === null || value === undefined)
-        return value;
-    if (field.columnType === mysqlTypes.longlong) {
-        if (policy.bigint === "bigint")
-            return BigInt(String(value));
-        if (policy.bigint === "number") {
-            const result = finite(String(value), "bigint");
-            if (!Number.isSafeInteger(result))
-                throw new RangeError(`bigint value ${value} exceeds JavaScript's safe integer range`);
-            return result;
-        }
-        return String(value);
-    }
-    if (field.columnType === mysqlTypes.decimal) {
-        if (policy.decimal === "number")
-            return finite(String(value), "decimal");
-        if (policy.decimal === "Decimal") {
-            if (decimal === undefined)
-                throw new TypeError("decimal=Decimal requires a decimal(value) codec");
-            return decimal(String(value));
-        }
-        return String(value);
-    }
-    if ([mysqlTypes.date, mysqlTypes.datetime, mysqlTypes.timestamp].includes(field.columnType)) {
-        return policy.date === "string" ? String(value) : value instanceof Date ? value : new Date(String(value));
-    }
-    if (field.columnType === mysqlTypes.json && policy.json === "string")
-        return typeof value === "string" ? value : JSON.stringify(value);
-    if (field.columnType === mysqlTypes.tiny && field.columnLength === 1 && policy.tinyint1 === "boolean")
-        return value === true || value === 1 || value === "1";
-    return value;
+function createMySqlConnectionOperation() {
+    let finish;
+    const completion = new Promise((resolve) => {
+        finish = resolve;
+    });
+    return { completion, finish };
 }
 class MySqlDatabaseImplementation {
     #pool;
     #connection;
     #ownsPool;
-    #policy;
-    #decimal;
     #depth;
-    constructor(pool, connection, ownsPool, policy, decimal, depth) {
+    #prepared;
+    #observation;
+    #decoderPlans;
+    #executes;
+    #streams;
+    #transactionState;
+    #scopeOpen = true;
+    executionCapabilities;
+    [adapterCapabilities];
+    constructor(pool, connection, ownsPool, depth, prepared, decoderPlans, observation, transactionState) {
         this.#pool = pool;
         this.#connection = connection;
         this.#ownsPool = ownsPool;
-        this.#policy = policy;
-        this.#decimal = decimal;
         this.#depth = depth;
+        this.#prepared = prepared;
+        this.#decoderPlans = decoderPlans;
+        this.#observation = observation;
+        this.#executes = connection === undefined ? undefined : new Set();
+        this.#streams = connection === undefined ? undefined : new Set();
+        this.#transactionState = transactionState;
+        this.executionCapabilities = Object.freeze({
+            cancellation: pool.executionCapabilities?.cancellation ?? false,
+            deadlines: pool.executionCapabilities?.deadlines ?? false,
+        });
+        const bulkTransport = {
+            loadData: (statement, chunks, options) => this.#loadData(statement, chunks, options),
+        };
+        this[adapterCapabilities] = createAdapterCapabilityResolver(pool.bulkLoad === true ? [[mysqlBulk, createMySqlBulkCapability(bulkTransport)]] : []);
     }
     async execute(query) {
-        const rendered = renderQuery(query, mysqlRenderer);
-        const result = await (this.#connection ?? this.#pool).execute(rendered.text, rendered.values.map(encoded));
+        if (this.#observation.observer === undefined) {
+            return this.#validateRows(query, await this.#executeUnobserved(query));
+        }
+        return this.#observeQuery(query, "many", async () => this.#validateRows(query, await this.#executeUnobserved(query)));
+    }
+    async #executeUnobserved(query) {
+        this.#assertScopeOpen();
+        this.#assertConnectionAvailable("execute a query");
+        if (this.#connection === undefined)
+            return this.#executeOn(this.#pool, query);
+        const operation = createMySqlConnectionOperation();
+        this.#executes.add(operation);
+        this.#transactionState.execute = operation;
+        try {
+            return await this.#executeOn(this.#connection, query);
+        }
+        finally {
+            this.#executes.delete(operation);
+            if (this.#transactionState?.execute === operation)
+                this.#transactionState.execute = undefined;
+            operation.finish();
+        }
+    }
+    async all(query, options) {
+        if (this.#observation.observer === undefined) {
+            return this.#validateRows(query, await this.#allUnobserved(query, options));
+        }
+        return this.#observeQuery(query, "many", async () => this.#validateRows(query, await this.#allUnobserved(query, options)));
+    }
+    async #allUnobserved(query, options) {
+        if (options === undefined || (options.signal === undefined && options.deadline === undefined))
+            return this.#executeUnobserved(query);
+        assertExecutionCapabilities(this.executionCapabilities, options);
+        this.#assertScopeOpen();
+        this.#assertConnectionAvailable("execute a query");
+        if (options.signal?.aborted || (options.deadline !== undefined && Number(options.deadline) <= Date.now())) {
+            return runControlledExecution(options, async () => [], () => undefined);
+        }
+        if (this.#connection === undefined) {
+            const connection = await this.#pool.getConnection();
+            if (connection.destroy === undefined) {
+                connection.release();
+                throw new UnsupportedExecutionCapabilityError(options.signal === undefined ? "deadlines" : "cancellation");
+            }
+            let discarded = false;
+            try {
+                return await this.#executeControlledOn(connection, query, options, () => {
+                    connection.destroy();
+                    discarded = true;
+                });
+            }
+            finally {
+                if (!discarded)
+                    connection.release();
+            }
+        }
+        const connection = this.#connection;
+        if (connection.destroy === undefined) {
+            throw new UnsupportedExecutionCapabilityError(options.signal === undefined ? "deadlines" : "cancellation");
+        }
+        const operationState = createMySqlConnectionOperation();
+        this.#executes.add(operationState);
+        this.#transactionState.execute = operationState;
+        try {
+            return await this.#executeControlledOn(connection, query, options, () => {
+                this.#transactionState.usable = false;
+                connection.destroy();
+                this.#transactionState.discarded = true;
+            });
+        }
+        finally {
+            this.#executes.delete(operationState);
+            if (this.#transactionState?.execute === operationState)
+                this.#transactionState.execute = undefined;
+            operationState.finish();
+        }
+    }
+    async #executeControlledOn(connection, query, options, cancel) {
+        return runControlledExecution(options, () => this.#executeOn(connection, query), cancel);
+    }
+    async one(query, options) {
+        if (this.#observation.observer === undefined) {
+            const rows = await this.#validateRows(query, await this.#allUnobserved(query, options));
+            if (rows.length !== 1)
+                throw new QueryCardinalityError("one", rows.length);
+            return rows[0];
+        }
+        const rows = await this.#observeQuery(query, "one", async () => {
+            const result = await this.#validateRows(query, await this.#allUnobserved(query, options));
+            if (result.length !== 1)
+                throw new QueryCardinalityError("one", result.length);
+            return result;
+        });
+        return rows[0];
+    }
+    async maybeOne(query, options) {
+        if (this.#observation.observer === undefined) {
+            const rows = await this.#validateRows(query, await this.#allUnobserved(query, options));
+            if (rows.length > 1)
+                throw new QueryCardinalityError("maybeOne", rows.length);
+            return rows[0];
+        }
+        const rows = await this.#observeQuery(query, "maybeOne", async () => {
+            const result = await this.#validateRows(query, await this.#allUnobserved(query, options));
+            if (result.length > 1)
+                throw new QueryCardinalityError("maybeOne", result.length);
+            return result;
+        });
+        return rows[0];
+    }
+    async #observeQuery(query, cardinality, operation) {
+        if (this.#observation.observer === undefined)
+            return operation();
+        const observation = startDatabaseObservation(this.#observation.observer, {
+            kind: "query",
+            dialect: "mysql",
+            grammarVersion: MYSQL_DIALECT_VERSION,
+            transactionDepth: this.#depth,
+            fingerprint: mysqlQueryFingerprint(this.#observation, query),
+            cardinality,
+            prepared: this.#prepared.queries.has(queryResultValidationSource(query)),
+        });
+        if (observation === undefined)
+            return operation();
+        try {
+            const rows = await observation.run(operation);
+            observation.end({ status: "success", rowCount: rows.length });
+            return rows;
+        }
+        catch (error) {
+            observation.end(databaseErrorCompletion(error), error);
+            throw error;
+        }
+    }
+    async #executeOn(executor, query) {
+        const prepared = this.#prepared.queries.get(queryResultValidationSource(query));
+        const rendered = prepared?.rendered ?? renderQuery(query, mysqlRenderer);
+        const result = await executor.execute(rendered.text, rendered.values.map(encodeMySqlValue));
         if (!Array.isArray(result.rows))
             return [];
-        const fields = result.fields ?? [];
-        return result.rows.map((row) => Object.fromEntries(Object.entries(row).map(([key, value]) => {
-            const field = fields.find((candidate) => candidate.name === key);
-            return [key, field === undefined ? value : decode(value, field, this.#policy, this.#decimal)];
-        })));
+        const decoders = this.#decoderPlans.get(result.fields ?? []);
+        return decodeMySqlRows(result.rows, decoders);
+    }
+    async batch(queries) {
+        if (queries.length === 0)
+            return emptyBatchResults;
+        if (this.#observation.observer === undefined) {
+            return this.#validateBatch(queries, await this.#batchUnobserved(queries));
+        }
+        return this.#observeBatch(queries, async () => this.#validateBatch(queries, await this.#batchUnobserved(queries)));
+    }
+    async #batchUnobserved(queries) {
+        this.#assertScopeOpen();
+        this.#assertConnectionAvailable("execute a batch");
+        if (queries.length === 0)
+            return emptyBatchResults;
+        const orderedQueries = [...queries];
+        if (this.#connection !== undefined) {
+            const operation = createMySqlConnectionOperation();
+            this.#transactionState.batch = operation;
+            try {
+                return await this.#executeBatchOn(this.#connection, orderedQueries, () => this.#assertBatchCanContinue(operation));
+            }
+            finally {
+                if (this.#transactionState?.batch === operation)
+                    this.#transactionState.batch = undefined;
+                operation.finish();
+            }
+        }
+        const connection = await this.#pool.getConnection();
+        let results;
+        try {
+            results = await this.#executeBatchOn(connection, orderedQueries);
+        }
+        catch (error) {
+            try {
+                connection.release();
+            }
+            catch {
+                /* Preserve the batch execution failure. */
+            }
+            throw error;
+        }
+        connection.release();
+        return results;
+    }
+    async #observeBatch(queries, operation) {
+        if (this.#observation.observer === undefined)
+            return operation();
+        const fingerprints = Object.freeze([...queries].map((query) => mysqlQueryFingerprint(this.#observation, query)));
+        const observation = startDatabaseObservation(this.#observation.observer, {
+            kind: "batch",
+            dialect: "mysql",
+            grammarVersion: MYSQL_DIALECT_VERSION,
+            transactionDepth: this.#depth,
+            fingerprints,
+            size: queries.length,
+        });
+        if (observation === undefined)
+            return operation();
+        try {
+            const results = await observation.run(operation);
+            observation.end({ status: "success" });
+            return results;
+        }
+        catch (error) {
+            observation.end(databaseErrorCompletion(error), error);
+            throw error;
+        }
+    }
+    async #executeBatchOn(connection, queries, beforeEach) {
+        const results = [];
+        for (const query of queries) {
+            beforeEach?.();
+            results.push(await this.#executeOn(connection, query));
+        }
+        return results;
+    }
+    stream(query, options = {}) {
+        this.#assertScopeOpen();
+        const prepared = this.#prepared.queries.get(queryResultValidationSource(query));
+        const rendered = prepared?.rendered ?? renderQuery(query, mysqlRenderer);
+        const batchSize = validateMySqlStreamBatchSize(options.batchSize);
+        let exposedStream;
+        const queryStream = createMySqlQueryStream({
+            openConnection: async () => {
+                if (this.#connection !== undefined) {
+                    this.#assertScopeOpen();
+                    this.#assertConnectionAvailable("start another query stream");
+                    this.#transactionState.active = exposedStream;
+                    return { connection: this.#connection, release: false };
+                }
+                return { connection: await this.#pool.getConnection(), release: true };
+            },
+            text: rendered.text,
+            values: rendered.values.map(encodeMySqlValue),
+            batchSize,
+            decoderPlans: this.#decoderPlans,
+            onClose: () => {
+                this.#streams?.delete(exposedStream);
+                if (this.#transactionState?.active === exposedStream)
+                    this.#transactionState.active = undefined;
+            },
+        });
+        const validatedStream = hasQueryResultValidator(query)
+            ? validateQueryResultStream(query, queryStream, mysqlQueryFingerprint(this.#observation, query))
+            : queryStream;
+        exposedStream =
+            this.#observation.observer === undefined
+                ? validatedStream
+                : observeQueryStream(validatedStream, this.#observation.observer, {
+                    kind: "stream",
+                    dialect: "mysql",
+                    grammarVersion: MYSQL_DIALECT_VERSION,
+                    transactionDepth: this.#depth,
+                    fingerprint: mysqlQueryFingerprint(this.#observation, query),
+                    prepared: prepared !== undefined,
+                });
+        this.#streams?.add(exposedStream);
+        return exposedStream;
+    }
+    async #validateRows(query, rows) {
+        if (!hasQueryResultValidator(query))
+            return rows;
+        return validateQueryResultRows(query, rows, mysqlQueryFingerprint(this.#observation, query));
+    }
+    async #validateBatch(queries, results) {
+        let validated;
+        const queryList = queries;
+        const resultList = results;
+        for (let index = 0; index < queryList.length; index += 1) {
+            const query = queryList[index];
+            if (!hasQueryResultValidator(query))
+                continue;
+            validated ??= [...resultList];
+            validated[index] = await validateQueryResultRows(query, resultList[index], mysqlQueryFingerprint(this.#observation, query));
+        }
+        return (validated ?? results);
+    }
+    async #loadData(statement, chunks, options) {
+        assertExecutionCapabilities(this.executionCapabilities, options);
+        this.#assertScopeOpen();
+        this.#assertConnectionAvailable("start LOAD DATA");
+        const connection = this.#connection ?? (await this.#pool.getConnection());
+        if (connection.loadData === undefined) {
+            if (this.#connection === undefined)
+                connection.release();
+            throw new Error("MySQL LOAD DATA requires an adapter with an application-owned local infile stream implementation");
+        }
+        const state = createMySqlConnectionOperation();
+        if (this.#connection !== undefined)
+            this.#transactionState.bulk = state;
+        let discarded = false;
+        const discard = () => {
+            if (discarded || connection.destroy === undefined)
+                return;
+            discarded = true;
+            connection.destroy();
+            if (this.#transactionState !== undefined) {
+                this.#transactionState.usable = false;
+                this.#transactionState.discarded = true;
+            }
+        };
+        try {
+            await runControlledExecution(options, () => connection.loadData(statement, chunks), discard);
+            if (this.#connection === undefined)
+                connection.release();
+        }
+        catch (error) {
+            discard();
+            if (!discarded && this.#connection === undefined)
+                connection.release();
+            throw error;
+        }
+        finally {
+            if (this.#transactionState?.bulk === state)
+                this.#transactionState.bulk = undefined;
+            state.finish();
+        }
+    }
+    prepare(statementName, factory) {
+        this.#assertScopeOpen();
+        return prepareMySqlQuery(this.#prepared, mysqlRenderer, statementName, factory);
     }
     async transaction(fn) {
+        if (this.#observation.observer === undefined)
+            return this.#transactionUnobserved(fn);
+        const observation = startDatabaseObservation(this.#observation.observer, {
+            kind: "transaction",
+            dialect: "mysql",
+            grammarVersion: MYSQL_DIALECT_VERSION,
+            transactionDepth: this.#depth + 1,
+        });
+        if (observation === undefined)
+            return this.#transactionUnobserved(fn);
+        try {
+            const result = await observation.run(() => this.#transactionUnobserved(fn));
+            observation.end({ status: "success" });
+            return result;
+        }
+        catch (error) {
+            observation.end(databaseErrorCompletion(error), error);
+            throw error;
+        }
+    }
+    async #transactionUnobserved(fn) {
+        this.#assertScopeOpen();
         if (this.#connection !== undefined)
             return this.#nested(fn);
         const connection = await this.#pool.getConnection();
+        let transaction;
+        let result;
         try {
             await connection.beginTransaction();
-            const result = await fn(new _a(this.#pool, connection, false, this.#policy, this.#decimal, 1));
+            transaction = new _a(this.#pool, connection, false, 1, this.#prepared, this.#decoderPlans, this.#observation, { active: undefined, batch: undefined, bulk: undefined, execute: undefined, discarded: false, usable: true });
+            result = await fn(transaction);
+            transaction.#scopeOpen = false;
+            transaction.#transactionState.usable = false;
+            await transaction.#assertTransactionReadyForFinalize(true);
             await connection.commit();
-            return result;
         }
         catch (error) {
-            try {
-                await connection.rollback();
+            if (transaction !== undefined) {
+                transaction.#scopeOpen = false;
+                transaction.#transactionState.usable = false;
+                await transaction.#invalidateScope();
             }
-            catch {
-                /* Preserve the original failure. */
+            if (transaction === undefined || transaction.#transactionState?.discarded !== true) {
+                try {
+                    await connection.rollback();
+                }
+                catch {
+                    /* Preserve the original failure. */
+                }
+                try {
+                    connection.release();
+                }
+                catch {
+                    /* Preserve the original failure. */
+                }
             }
             throw error;
         }
-        finally {
-            connection.release();
-        }
+        connection.release();
+        return result;
     }
     async #nested(fn) {
+        this.#assertScopeOpen();
+        this.#assertConnectionAvailable("start a nested transaction");
         const connection = this.#connection;
         const depth = this.#depth + 1;
         const savepoint = `typed_sql_${depth}`;
         await connection.query(`SAVEPOINT ${savepoint}`);
+        let transaction;
         try {
-            const result = await fn(new _a(this.#pool, connection, false, this.#policy, this.#decimal, depth));
+            transaction = new _a(this.#pool, connection, false, depth, this.#prepared, this.#decoderPlans, this.#observation, this.#transactionState);
+            const result = await fn(transaction);
+            transaction.#scopeOpen = false;
+            await transaction.#assertTransactionReadyForFinalize();
             await connection.query(`RELEASE SAVEPOINT ${savepoint}`);
             return result;
         }
         catch (error) {
-            await connection.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+            if (transaction !== undefined)
+                await transaction.#invalidateScope();
+            if (this.#transactionState?.usable !== false) {
+                try {
+                    await connection.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+                }
+                catch {
+                    /* Preserve the original failure. */
+                }
+            }
             throw error;
         }
     }
+    async #rejectActiveStreams() {
+        if (this.#streams === undefined || this.#streams.size === 0)
+            return;
+        const active = [...this.#streams];
+        await Promise.allSettled(active.map((stream) => stream.close()));
+        throw new Error(`MySQL transaction callback returned with ${active.length} active query stream${active.length === 1 ? "" : "s"}; consume or close every stream before returning`);
+    }
+    async #closeStreams() {
+        const streams = new Set(this.#streams);
+        if (this.#transactionState?.active !== undefined)
+            streams.add(this.#transactionState.active);
+        if (streams.size === 0)
+            return;
+        await Promise.allSettled([...streams].map((stream) => stream.close()));
+    }
+    async #invalidateScope() {
+        this.#scopeOpen = false;
+        await this.#closeStreams();
+        await this.#settleExecutes();
+        await this.#settleBatch();
+        await this.#settleBulk();
+    }
+    async #assertTransactionReadyForFinalize(connectionFinalizing = false) {
+        const leakedExecutes = new Set(this.#executes);
+        if (this.#transactionState?.execute !== undefined)
+            leakedExecutes.add(this.#transactionState.execute);
+        const leakedBatch = this.#transactionState?.batch;
+        const leakedBulk = this.#transactionState?.bulk;
+        await this.#rejectActiveStreams();
+        const active = this.#transactionState?.active;
+        if (active !== undefined) {
+            await Promise.allSettled([active.close()]);
+            throw new Error("MySQL transaction callback returned while a nested query stream owned its connection; await nested work and close every stream before returning");
+        }
+        if (leakedExecutes.size > 0) {
+            await this.#settleExecuteOperations(leakedExecutes);
+            throw new Error("MySQL transaction callback returned while an execute operation owned its connection; await execute before returning");
+        }
+        if (leakedBatch !== undefined) {
+            await leakedBatch.completion;
+            throw new Error("MySQL transaction callback returned while an ordered batch owned its connection; await the batch before returning");
+        }
+        if (leakedBulk !== undefined) {
+            await leakedBulk.completion;
+            throw new Error("MySQL transaction callback returned while LOAD DATA owned its connection; await LOAD DATA before returning");
+        }
+        if (!connectionFinalizing && this.#transactionState?.usable === false)
+            throw new Error("This MySQL transaction connection is no longer active");
+    }
+    #assertConnectionAvailable(action) {
+        if (this.#transactionState?.active !== undefined)
+            throw new Error(`Cannot ${action} while a MySQL query stream owns the transaction connection`);
+        if (this.#transactionState?.batch !== undefined)
+            throw new Error(`Cannot ${action} while a MySQL ordered batch owns the transaction connection`);
+        if (this.#transactionState?.bulk !== undefined)
+            throw new Error(`Cannot ${action} while MySQL LOAD DATA owns the transaction connection`);
+        if (this.#transactionState?.execute !== undefined)
+            throw new Error(`Cannot ${action} while a MySQL execute operation owns the transaction connection`);
+    }
+    #assertBatchCanContinue(operation) {
+        this.#assertScopeOpen();
+        if (this.#transactionState?.batch !== operation)
+            throw new Error("This MySQL ordered batch no longer owns the transaction connection");
+    }
+    async #settleBatch() {
+        const batch = this.#transactionState?.batch;
+        if (batch !== undefined)
+            await batch.completion;
+    }
+    async #settleBulk() {
+        const bulk = this.#transactionState?.bulk;
+        if (bulk !== undefined)
+            await bulk.completion;
+    }
+    async #settleExecutes() {
+        const operations = new Set(this.#executes);
+        if (this.#transactionState?.execute !== undefined)
+            operations.add(this.#transactionState.execute);
+        await this.#settleExecuteOperations(operations);
+    }
+    async #settleExecuteOperations(operations) {
+        for (const operation of operations) {
+            await operation.completion;
+        }
+    }
+    #assertScopeOpen() {
+        if (this.#connection !== undefined && (!this.#scopeOpen || this.#transactionState?.usable === false))
+            throw new Error("This MySQL transaction scope is no longer active");
+    }
     async close() {
         if (this.#connection !== undefined)
             throw new Error("Cannot close a database from inside a transaction");
@@ -122,9 +582,9 @@ class MySqlDatabaseImplementation {
 }
 _a = MySqlDatabaseImplementation;
 export function createMySqlDatabase(options) {
-    const policy = { ...defaultRuntimePolicy, ...options.typePolicy };
-    if (policy.decimal === "Decimal" && options.decimal === undefined)
+    const typePolicy = { ...defaultRuntimeTypePolicy, ...options.typePolicy };
+    if (typePolicy.decimal === "Decimal" && options.decimal === undefined)
         throw new TypeError("decimal=Decimal requires a decimal(value) codec");
-    return new MySqlDatabaseImplementation(options.pool, undefined, options.ownsPool ?? false, policy, options.decimal, 0);
+    return new MySqlDatabaseImplementation(options.pool, undefined, options.ownsPool ?? false, 0, createMySqlPreparedQueryState(), new MySqlDecoderPlanCache(typePolicy, options.decimal), createMySqlObservationState(options.observer));
 }
 //# sourceMappingURL=runtime.js.map