@nextlyhq/adapter-mysql 0.0.2-alpha.71 → 0.0.2-alpha.73

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { DrizzleAdapter } from "@nextlyhq/adapter-drizzle";
-import { AdapterLogger, BaseAdapterConfig, DatabaseCapabilities, DatabaseError, DatabaseErrorKind, DeleteOptions, InsertOptions, JoinSpec, MySqlAdapterConfig, OrderBySpec, PoolConfig, PoolStats, SelectOptions, SqlParam, SslConfig, TransactionContext, TransactionOptions, UpdateOptions, UpsertOptions, WhereClause, WhereCondition, WhereOperator } from "@nextlyhq/adapter-drizzle/types";
+import { AdapterLogger, BaseAdapterConfig, DatabaseCapabilities, DatabaseError, DatabaseErrorKind, DeleteOptions, InsertOptions, JoinSpec, MySqlAdapterConfig, OrderBySpec, PoolConfig, PoolStats, SelectOptions, SessionOptions, SqlParam, SslConfig, StatementSession, TransactionContext, TransactionOptions, UpdateOptions, UpsertOptions, WhereClause, WhereCondition, WhereOperator } from "@nextlyhq/adapter-drizzle/types";
 import { AnyRelations } from "drizzle-orm";
 import { MySql2Database } from "drizzle-orm/mysql2";
 /**
@@ -45,6 +45,8 @@ export declare class MySqlAdapter extends DrizzleAdapter {
    * Connection pool instance.
    */
   private pool;
+  /** The `withSession` calls running, each on a connection of its own, for `disconnect` to wait for. */
+  private readonly sessions;
   /**
    * Connection state flag.
    */
@@ -54,6 +56,7 @@ export declare class MySqlAdapter extends DrizzleAdapter {
    * string at connect. Undefined until then, which callers treat as not known.
    */
   private sharedRowLock;
+  private functionalIndexes;
   /**
    * Creates a new MySQL adapter instance.
    *
@@ -78,7 +81,8 @@ export declare class MySqlAdapter extends DrizzleAdapter {
    *
    * @remarks
    * This method is idempotent - calling it multiple times is safe.
-   * It waits for all connections to be released before shutting down.
+   * It waits for all connections to be released before shutting down,
+   * including each running `withSession`'s connection of its own.
    */
   disconnect(): Promise<void>;
   /**
@@ -121,6 +125,27 @@ export declare class MySqlAdapter extends DrizzleAdapter {
    * MySQL's quirks with nested transactions.
    */
   transaction<T>(work: (tx: TransactionContext) => Promise<T>, options?: TransactionOptions): Promise<T>;
+  /**
+   * Runs `work` on a connection of its own, opened for it with the pool's
+   * connection settings, outside a transaction, each statement committing as
+   * it runs.
+   *
+   * @remarks
+   * Not a pooled connection: on a server whose sessions start with autocommit
+   * off, one can hold a transaction an earlier caller left open, and turning
+   * autocommit on would commit that caller's writes. A new connection holds
+   * nothing. It does not count against `pool.max`.
+   *
+   * Each statement commits as it runs, whatever the server's own autocommit
+   * default. With `strictSqlMode` the session runs in strict mode, as a
+   * transaction given the same option does, so a statement that would cut a
+   * value short fails and changes nothing. The connection is closed
+   * afterwards, whether `work` finished or threw, so whatever `work` set on
+   * its session (a temporary table, a session variable, a lock) ends with it.
+   */
+  override withSession<T>(work: (session: StatementSession) => Promise<T>, options?: SessionOptions): Promise<T>;
+  /** `withSession`'s work, on a connection it opens and closes. */
+  private runSession;
   /** The attempts `transaction` makes, each on a connection of its own. */
   private runTransactionAttempts;
   /**
@@ -185,12 +210,29 @@ export declare class MySqlAdapter extends DrizzleAdapter {
    * Builds mysql2 Pool configuration from adapter config.
    */
   private buildPoolConfig;
+  /**
+   * Builds the settings every connection opens with, pooled or not, from
+   * adapter config.
+   */
+  private buildConnectionConfig;
+  /** Where to connect: the connection string, or the explicit options. */
+  private buildAddressConfig;
+  /** mysql2's `ssl` option for the adapter's `ssl` setting. */
+  private buildSslConfig;
   /**
    * Begins a transaction with the specified options, recording in `changed`
    * each session setting it changes, as it changes it, for `restoreSession`
    * to put back.
    */
   private beginTransaction;
+  /**
+   * Strict mode for the rest of this connection's session: an INSERT, UPDATE
+   * or ALTER that would cut a string to its column's length, or clamp a
+   * number to its range, fails instead of applying with a warning. Added to
+   * the session's own mode, so every other flag it had still holds, and
+   * recorded in `changed` for `restoreSession` to put back.
+   */
+  private enterStrictMode;
   /**
    * Creates a TransactionContext for the given connection.
    *

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { DrizzleAdapter } from "@nextlyhq/adapter-drizzle";
-import { AdapterLogger, BaseAdapterConfig, DatabaseCapabilities, DatabaseError, DatabaseErrorKind, DeleteOptions, InsertOptions, JoinSpec, MySqlAdapterConfig, OrderBySpec, PoolConfig, PoolStats, SelectOptions, SqlParam, SslConfig, TransactionContext, TransactionOptions, UpdateOptions, UpsertOptions, WhereClause, WhereCondition, WhereOperator } from "@nextlyhq/adapter-drizzle/types";
+import { AdapterLogger, BaseAdapterConfig, DatabaseCapabilities, DatabaseError, DatabaseErrorKind, DeleteOptions, InsertOptions, JoinSpec, MySqlAdapterConfig, OrderBySpec, PoolConfig, PoolStats, SelectOptions, SessionOptions, SqlParam, SslConfig, StatementSession, TransactionContext, TransactionOptions, UpdateOptions, UpsertOptions, WhereClause, WhereCondition, WhereOperator } from "@nextlyhq/adapter-drizzle/types";
 import { AnyRelations } from "drizzle-orm";
 import { MySql2Database } from "drizzle-orm/mysql2";
 /**
@@ -45,6 +45,8 @@ export declare class MySqlAdapter extends DrizzleAdapter {
    * Connection pool instance.
    */
   private pool;
+  /** The `withSession` calls running, each on a connection of its own, for `disconnect` to wait for. */
+  private readonly sessions;
   /**
    * Connection state flag.
    */
@@ -54,6 +56,7 @@ export declare class MySqlAdapter extends DrizzleAdapter {
    * string at connect. Undefined until then, which callers treat as not known.
    */
   private sharedRowLock;
+  private functionalIndexes;
   /**
    * Creates a new MySQL adapter instance.
    *
@@ -78,7 +81,8 @@ export declare class MySqlAdapter extends DrizzleAdapter {
    *
    * @remarks
    * This method is idempotent - calling it multiple times is safe.
-   * It waits for all connections to be released before shutting down.
+   * It waits for all connections to be released before shutting down,
+   * including each running `withSession`'s connection of its own.
    */
   disconnect(): Promise<void>;
   /**
@@ -121,6 +125,27 @@ export declare class MySqlAdapter extends DrizzleAdapter {
    * MySQL's quirks with nested transactions.
    */
   transaction<T>(work: (tx: TransactionContext) => Promise<T>, options?: TransactionOptions): Promise<T>;
+  /**
+   * Runs `work` on a connection of its own, opened for it with the pool's
+   * connection settings, outside a transaction, each statement committing as
+   * it runs.
+   *
+   * @remarks
+   * Not a pooled connection: on a server whose sessions start with autocommit
+   * off, one can hold a transaction an earlier caller left open, and turning
+   * autocommit on would commit that caller's writes. A new connection holds
+   * nothing. It does not count against `pool.max`.
+   *
+   * Each statement commits as it runs, whatever the server's own autocommit
+   * default. With `strictSqlMode` the session runs in strict mode, as a
+   * transaction given the same option does, so a statement that would cut a
+   * value short fails and changes nothing. The connection is closed
+   * afterwards, whether `work` finished or threw, so whatever `work` set on
+   * its session (a temporary table, a session variable, a lock) ends with it.
+   */
+  override withSession<T>(work: (session: StatementSession) => Promise<T>, options?: SessionOptions): Promise<T>;
+  /** `withSession`'s work, on a connection it opens and closes. */
+  private runSession;
   /** The attempts `transaction` makes, each on a connection of its own. */
   private runTransactionAttempts;
   /**
@@ -185,12 +210,29 @@ export declare class MySqlAdapter extends DrizzleAdapter {
    * Builds mysql2 Pool configuration from adapter config.
    */
   private buildPoolConfig;
+  /**
+   * Builds the settings every connection opens with, pooled or not, from
+   * adapter config.
+   */
+  private buildConnectionConfig;
+  /** Where to connect: the connection string, or the explicit options. */
+  private buildAddressConfig;
+  /** mysql2's `ssl` option for the adapter's `ssl` setting. */
+  private buildSslConfig;
   /**
    * Begins a transaction with the specified options, recording in `changed`
    * each session setting it changes, as it changes it, for `restoreSession`
    * to put back.
    */
   private beginTransaction;
+  /**
+   * Strict mode for the rest of this connection's session: an INSERT, UPDATE
+   * or ALTER that would cut a string to its column's length, or clamp a
+   * number to its range, fails instead of applying with a warning. Added to
+   * the session's own mode, so every other flag it had still holds, and
+   * recorded in `changed` for `restoreSession` to put back.
+   */
+  private enterStrictMode;
   /**
    * Creates a TransactionContext for the given connection.
    *

package/dist/index.mjs

@@ -236,6 +236,8 @@ var MySqlAdapter = class extends DrizzleAdapter {
 	* Connection pool instance.
 	*/
 	pool = null;
+	/** The `withSession` calls running, each on a connection of its own, for `disconnect` to wait for. */
+	sessions = /* @__PURE__ */ new Set();
 	/**
 	* Connection state flag.
 	*/
@@ -245,6 +247,7 @@ var MySqlAdapter = class extends DrizzleAdapter {
 	* string at connect. Undefined until then, which callers treat as not known.
 	*/
 	sharedRowLock;
+	functionalIndexes;
 	/**
 	* Creates a new MySQL adapter instance.
 	*
@@ -275,8 +278,9 @@ var MySqlAdapter = class extends DrizzleAdapter {
 			const connection = await this.pool.getConnection();
 			try {
 				await connection.query("SELECT 1");
-				const { variant } = await checkDialectVersion(connection, "mysql", { onWarning: (msg) => this.config.logger?.warn?.(msg) });
+				const { variant, functionalIndexes } = await checkDialectVersion(connection, "mysql", { onWarning: (msg) => this.config.logger?.warn?.(msg) });
 				this.sharedRowLock = acceptsForShare(variant);
+				this.functionalIndexes = functionalIndexes;
 				this.connected = true;
 				if (this.config.logger?.info) this.config.logger.info("MySQL connection established", {
 					host: this.config.host ?? "from URL",
@@ -299,7 +303,8 @@ var MySqlAdapter = class extends DrizzleAdapter {
 	*
 	* @remarks
 	* This method is idempotent - calling it multiple times is safe.
-	* It waits for all connections to be released before shutting down.
+	* It waits for all connections to be released before shutting down,
+	* including each running `withSession`'s connection of its own.
 	*/
 	async disconnect() {
 		const pool = this.pool;
@@ -308,6 +313,7 @@ var MySqlAdapter = class extends DrizzleAdapter {
 		this.drizzleByRelations = /* @__PURE__ */ new WeakMap();
 		if (!pool) return;
 		try {
+			await Promise.allSettled([...this.sessions]);
 			await pool.end();
 			if (this.config.logger?.info) this.config.logger.info("MySQL connection closed");
 		} finally {
@@ -389,6 +395,64 @@ var MySqlAdapter = class extends DrizzleAdapter {
 	async transaction(work, options) {
 		return this.runInFlowTransaction(() => this.runTransactionAttempts(work, options));
 	}
+	/**
+	* Runs `work` on a connection of its own, opened for it with the pool's
+	* connection settings, outside a transaction, each statement committing as
+	* it runs.
+	*
+	* @remarks
+	* Not a pooled connection: on a server whose sessions start with autocommit
+	* off, one can hold a transaction an earlier caller left open, and turning
+	* autocommit on would commit that caller's writes. A new connection holds
+	* nothing. It does not count against `pool.max`.
+	*
+	* Each statement commits as it runs, whatever the server's own autocommit
+	* default. With `strictSqlMode` the session runs in strict mode, as a
+	* transaction given the same option does, so a statement that would cut a
+	* value short fails and changes nothing. The connection is closed
+	* afterwards, whether `work` finished or threw, so whatever `work` set on
+	* its session (a temporary table, a session variable, a lock) ends with it.
+	*/
+	async withSession(work, options) {
+		this.refuseSessionInTransaction();
+		this.ensurePool();
+		const running = this.runSession(work, options);
+		this.sessions.add(running);
+		try {
+			return await running;
+		} finally {
+			this.sessions.delete(running);
+		}
+	}
+	/** `withSession`'s work, on a connection it opens and closes. */
+	async runSession(work, options) {
+		let connection;
+		try {
+			connection = await mysql.createConnection(this.buildConnectionConfig());
+		} catch (error) {
+			throw this.classifyError(error);
+		}
+		try {
+			try {
+				await connection.query("SET SESSION autocommit = 1");
+				if (options?.strictSqlMode) await this.enterStrictMode(connection, {});
+			} catch (error) {
+				throw this.classifyError(error);
+			}
+			return await work({ execute: async (statement, params = []) => {
+				const startTime = Date.now();
+				try {
+					const [rows] = await connection.query(statement, params);
+					if (this.config.logger?.query) this.config.logger.query(statement, params, Date.now() - startTime);
+					return rows;
+				} catch (error) {
+					throw this.classifyError(error, statement);
+				}
+			} });
+		} finally {
+			connection.destroy();
+		}
+	}
 	/** The attempts `transaction` makes, each on a connection of its own. */
 	async runTransactionAttempts(work, options) {
 		const pool = this.ensurePool();
@@ -459,7 +523,8 @@ var MySqlAdapter = class extends DrizzleAdapter {
 			supportsOnConflict: true,
 			maxParamsPerQuery: 65535,
 			maxIdentifierLength: 64,
-			sharedRowLock: this.sharedRowLock
+			sharedRowLock: this.sharedRowLock,
+			functionalIndexes: this.functionalIndexes
 		};
 	}
 	/**
@@ -558,35 +623,51 @@ var MySqlAdapter = class extends DrizzleAdapter {
 	* Builds mysql2 Pool configuration from adapter config.
 	*/
 	buildPoolConfig() {
-		const config = {};
-		if (this.config.url) config.uri = this.config.url;
-		else {
-			if (this.config.host) config.host = this.config.host;
-			if (this.config.port) config.port = this.config.port;
-			if (this.config.database) config.database = this.config.database;
-			if (this.config.user) config.user = this.config.user;
-			if (this.config.password) config.password = this.config.password;
-		}
+		const config = this.buildConnectionConfig();
 		config.connectionLimit = this.config.pool?.max ?? DEFAULT_POOL_CONFIG.max;
 		config.idleTimeout = this.config.pool?.idleTimeoutMs ?? DEFAULT_POOL_CONFIG.idleTimeoutMs;
-		config.connectTimeout = this.config.pool?.connectionTimeoutMs ?? DEFAULT_POOL_CONFIG.connectionTimeoutMs;
 		config.waitForConnections = true;
 		config.queueLimit = 0;
-		if (this.config.ssl) {
-			if (typeof this.config.ssl === "boolean") config.ssl = this.config.ssl ? {} : void 0;
-			else config.ssl = {
-				rejectUnauthorized: this.config.ssl.rejectUnauthorized,
-				ca: this.config.ssl.ca,
-				cert: this.config.ssl.cert,
-				key: this.config.ssl.key
-			};
-		}
+		return config;
+	}
+	/**
+	* Builds the settings every connection opens with, pooled or not, from
+	* adapter config.
+	*/
+	buildConnectionConfig() {
+		const config = this.buildAddressConfig();
+		config.connectTimeout = this.config.pool?.connectionTimeoutMs ?? DEFAULT_POOL_CONFIG.connectionTimeoutMs;
+		if (this.config.ssl) config.ssl = this.buildSslConfig(this.config.ssl);
 		if (this.config.timezone) config.timezone = this.config.timezone;
 		if (this.config.charset) config.charset = this.config.charset;
 		config.multipleStatements = false;
 		config.dateStrings = false;
 		return config;
 	}
+	/** Where to connect: the connection string, or the explicit options. */
+	buildAddressConfig() {
+		if (this.config.url) return { uri: this.config.url };
+		const { host, port, database, user, password } = this.config;
+		const config = {
+			host,
+			port,
+			database,
+			user,
+			password
+		};
+		for (const key of Object.keys(config)) if (!config[key]) delete config[key];
+		return config;
+	}
+	/** mysql2's `ssl` option for the adapter's `ssl` setting. */
+	buildSslConfig(ssl) {
+		if (typeof ssl === "boolean") return ssl ? {} : void 0;
+		return {
+			rejectUnauthorized: ssl.rejectUnauthorized,
+			ca: ssl.ca,
+			cert: ssl.cert,
+			key: ssl.key
+		};
+	}
 	/**
 	* Begins a transaction with the specified options, recording in `changed`
 	* each session setting it changes, as it changes it, for `restoreSession`
@@ -611,12 +692,20 @@ var MySqlAdapter = class extends DrizzleAdapter {
 			await connection.query(`SET SESSION innodb_lock_wait_timeout = ${timeoutSeconds}`);
 			changed.lockWaitTimeout = Number.isInteger(previous) ? previous : null;
 		}
-		if (options?.strictSqlMode) {
-			const [rows] = await connection.query("SELECT @@SESSION.sql_mode AS mode");
-			const previous = rows[0]?.mode;
-			await connection.query("SET SESSION sql_mode = TRIM(BOTH ',' FROM CONCAT(@@SESSION.sql_mode, ',STRICT_ALL_TABLES'))");
-			changed.sqlMode = typeof previous === "string" ? previous : null;
-		}
+		if (options?.strictSqlMode) await this.enterStrictMode(connection, changed);
+	}
+	/**
+	* Strict mode for the rest of this connection's session: an INSERT, UPDATE
+	* or ALTER that would cut a string to its column's length, or clamp a
+	* number to its range, fails instead of applying with a warning. Added to
+	* the session's own mode, so every other flag it had still holds, and
+	* recorded in `changed` for `restoreSession` to put back.
+	*/
+	async enterStrictMode(connection, changed) {
+		const [rows] = await connection.query("SELECT @@SESSION.sql_mode AS mode");
+		const previous = rows[0]?.mode;
+		changed.sqlMode = typeof previous === "string" ? previous : null;
+		await connection.query("SET SESSION sql_mode = TRIM(BOTH ',' FROM CONCAT(@@SESSION.sql_mode, ',STRICT_ALL_TABLES'))");
 	}
 	/**
 	* Creates a TransactionContext for the given connection.