@fragno-dev/workflows 0.0.1

package/dist/node/node_modules/.pnpm/mysql2@3.16.1/node_modules/mysql2/lib/base/connection.js

@@ -0,0 +1,635 @@
+import { __commonJS, __require } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_sqlstring } from "../../../../../sqlstring@2.3.3/node_modules/sqlstring/index.js";
+import { require_connection_config } from "../connection_config.js";
+import { require_lib } from "../../../../../lru.min@1.1.3/node_modules/lru.min/lib/index.js";
+import { require_denque } from "../../../../../denque@2.1.0/node_modules/denque/index.js";
+import { require_packet_parser } from "../packet_parser.js";
+import { require_charset_encodings } from "../constants/charset_encodings.js";
+import { require_packets } from "../packets/index.js";
+import { require_commands } from "../commands/index.js";
+import { require_named_placeholders } from "../../../../../named-placeholders@1.1.6/node_modules/named-placeholders/index.js";
+
+//#region ../../node_modules/.pnpm/mysql2@3.16.1/node_modules/mysql2/lib/base/connection.js
+var require_connection = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/mysql2@3.16.1/node_modules/mysql2/lib/base/connection.js": ((exports, module) => {
+	const Net = __require("net");
+	const Tls = __require("tls");
+	const Timers = __require("timers");
+	const EventEmitter = __require("events").EventEmitter;
+	const Readable = __require("stream").Readable;
+	const Queue = require_denque();
+	const SqlString = require_sqlstring();
+	const { createLRU } = require_lib();
+	const PacketParser = require_packet_parser();
+	const Packets = require_packets();
+	const Commands = require_commands();
+	const ConnectionConfig = require_connection_config();
+	const CharsetToEncoding = require_charset_encodings();
+	let _connectionId = 0;
+	let convertNamedPlaceholders = null;
+	var BaseConnection = class BaseConnection extends EventEmitter {
+		constructor(opts) {
+			super();
+			this.config = opts.config;
+			if (!opts.config.stream) if (opts.config.socketPath) this.stream = Net.connect(opts.config.socketPath);
+			else {
+				this.stream = Net.connect(opts.config.port, opts.config.host);
+				if (this.config.enableKeepAlive) this.stream.on("connect", () => {
+					this.stream.setKeepAlive(true, this.config.keepAliveInitialDelay);
+				});
+				this.stream.setNoDelay(true);
+			}
+			else if (typeof opts.config.stream === "function") this.stream = opts.config.stream(opts);
+			else this.stream = opts.config.stream;
+			this._internalId = _connectionId++;
+			this._commands = new Queue();
+			this._command = null;
+			this._paused = false;
+			this._paused_packets = new Queue();
+			this._statements = createLRU({
+				max: this.config.maxPreparedStatements,
+				onEviction: function(_, statement) {
+					statement.close();
+				}
+			});
+			this.serverCapabilityFlags = 0;
+			this.authorized = false;
+			this.sequenceId = 0;
+			this.compressedSequenceId = 0;
+			this.threadId = null;
+			this._handshakePacket = null;
+			this._fatalError = null;
+			this._protocolError = null;
+			this._outOfOrderPackets = [];
+			this.clientEncoding = CharsetToEncoding[this.config.charsetNumber];
+			this.stream.on("error", this._handleNetworkError.bind(this));
+			this.packetParser = new PacketParser((p) => {
+				this.handlePacket(p);
+			});
+			this.stream.on("data", (data) => {
+				if (this.connectTimeout) {
+					Timers.clearTimeout(this.connectTimeout);
+					this.connectTimeout = null;
+				}
+				this.packetParser.execute(data);
+			});
+			this.stream.on("end", () => {
+				this.emit("end");
+			});
+			this.stream.on("close", () => {
+				if (this._closing) return;
+				if (!this._protocolError) {
+					this._protocolError = /* @__PURE__ */ new Error("Connection lost: The server closed the connection.");
+					this._protocolError.fatal = true;
+					this._protocolError.code = "PROTOCOL_CONNECTION_LOST";
+				}
+				this._notifyError(this._protocolError);
+			});
+			let handshakeCommand;
+			if (!this.config.isServer) {
+				handshakeCommand = new Commands.ClientHandshake(this.config.clientFlags);
+				handshakeCommand.on("end", () => {
+					if (!handshakeCommand.handshake || this._fatalError || this._protocolError) return;
+					this._handshakePacket = handshakeCommand.handshake;
+					this.threadId = handshakeCommand.handshake.connectionId;
+					this.emit("connect", handshakeCommand.handshake);
+				});
+				handshakeCommand.on("error", (err) => {
+					this._closing = true;
+					this._notifyError(err);
+				});
+				this.addCommand(handshakeCommand);
+			}
+			this.serverEncoding = "utf8";
+			if (this.config.connectTimeout) {
+				const timeoutHandler = this._handleTimeoutError.bind(this);
+				this.connectTimeout = Timers.setTimeout(timeoutHandler, this.config.connectTimeout);
+			}
+		}
+		_addCommandClosedState(cmd) {
+			const err = /* @__PURE__ */ new Error("Can't add new command when connection is in closed state");
+			err.fatal = true;
+			if (cmd.onResult) cmd.onResult(err);
+			else this.emit("error", err);
+		}
+		_handleFatalError(err) {
+			err.fatal = true;
+			this.stream.removeAllListeners("data");
+			this.addCommand = this._addCommandClosedState;
+			this.write = () => {
+				this.emit("error", /* @__PURE__ */ new Error("Can't write in closed state"));
+			};
+			this._notifyError(err);
+			this._fatalError = err;
+		}
+		_handleNetworkError(err) {
+			if (this.connectTimeout) {
+				Timers.clearTimeout(this.connectTimeout);
+				this.connectTimeout = null;
+			}
+			if (err.code === "ECONNRESET" && this._closing) return;
+			this._handleFatalError(err);
+		}
+		_handleTimeoutError() {
+			if (this.connectTimeout) {
+				Timers.clearTimeout(this.connectTimeout);
+				this.connectTimeout = null;
+			}
+			this.stream.destroy && this.stream.destroy();
+			const err = /* @__PURE__ */ new Error("connect ETIMEDOUT");
+			err.errorno = "ETIMEDOUT";
+			err.code = "ETIMEDOUT";
+			err.syscall = "connect";
+			this._handleNetworkError(err);
+		}
+		_notifyError(err) {
+			if (this.connectTimeout) {
+				Timers.clearTimeout(this.connectTimeout);
+				this.connectTimeout = null;
+			}
+			if (this._fatalError) return;
+			let command;
+			let bubbleErrorToConnection = !this._command;
+			if (this._command && this._command.onResult) {
+				this._command.onResult(err);
+				this._command = null;
+			} else if (!(this._command && this._command.constructor === Commands.ClientHandshake && this._commands.length > 0)) bubbleErrorToConnection = true;
+			while (command = this._commands.shift()) if (command.onResult) command.onResult(err);
+			else bubbleErrorToConnection = true;
+			if (bubbleErrorToConnection || this._pool) this.emit("error", err);
+			if (err.fatal) this.close();
+		}
+		write(buffer) {
+			if (!this.stream.write(buffer, (err) => {
+				if (err) this._handleNetworkError(err);
+			})) this.stream.emit("pause");
+		}
+		_resetSequenceId() {
+			this.sequenceId = 0;
+			this.compressedSequenceId = 0;
+		}
+		_bumpCompressedSequenceId(numPackets) {
+			this.compressedSequenceId += numPackets;
+			this.compressedSequenceId %= 256;
+		}
+		_bumpSequenceId(numPackets) {
+			this.sequenceId += numPackets;
+			this.sequenceId %= 256;
+		}
+		writePacket(packet) {
+			const MAX_PACKET_LENGTH = 16777215;
+			const length = packet.length();
+			let chunk, offset, header;
+			if (length < MAX_PACKET_LENGTH) {
+				packet.writeHeader(this.sequenceId);
+				if (this.config.debug) {
+					console.log(`${this._internalId} ${this.connectionId} <== ${this._command._commandName}#${this._command.stateName()}(${[
+						this.sequenceId,
+						packet._name,
+						packet.length()
+					].join(",")})`);
+					console.log(`${this._internalId} ${this.connectionId} <== ${packet.buffer.toString("hex")}`);
+				}
+				this._bumpSequenceId(1);
+				this.write(packet.buffer);
+			} else {
+				if (this.config.debug) {
+					console.log(`${this._internalId} ${this.connectionId} <== Writing large packet, raw content not written:`);
+					console.log(`${this._internalId} ${this.connectionId} <== ${this._command._commandName}#${this._command.stateName()}(${[
+						this.sequenceId,
+						packet._name,
+						packet.length()
+					].join(",")})`);
+				}
+				for (offset = 4; offset < 4 + length; offset += MAX_PACKET_LENGTH) {
+					chunk = packet.buffer.slice(offset, offset + MAX_PACKET_LENGTH);
+					if (chunk.length === MAX_PACKET_LENGTH) header = Buffer.from([
+						255,
+						255,
+						255,
+						this.sequenceId
+					]);
+					else header = Buffer.from([
+						chunk.length & 255,
+						chunk.length >> 8 & 255,
+						chunk.length >> 16 & 255,
+						this.sequenceId
+					]);
+					this._bumpSequenceId(1);
+					this.write(header);
+					this.write(chunk);
+				}
+			}
+		}
+		startTLS(onSecure) {
+			if (this.config.debug) console.log("Upgrading connection to TLS");
+			const secureContext = Tls.createSecureContext({
+				ca: this.config.ssl.ca,
+				cert: this.config.ssl.cert,
+				ciphers: this.config.ssl.ciphers,
+				key: this.config.ssl.key,
+				passphrase: this.config.ssl.passphrase,
+				minVersion: this.config.ssl.minVersion,
+				maxVersion: this.config.ssl.maxVersion
+			});
+			const rejectUnauthorized = this.config.ssl.rejectUnauthorized;
+			const verifyIdentity = this.config.ssl.verifyIdentity;
+			const servername = Net.isIP(this.config.host) ? void 0 : this.config.host;
+			let secureEstablished = false;
+			this.stream.removeAllListeners("data");
+			const secureSocket = Tls.connect({
+				rejectUnauthorized,
+				requestCert: rejectUnauthorized,
+				checkServerIdentity: verifyIdentity ? Tls.checkServerIdentity : function() {},
+				secureContext,
+				isServer: false,
+				socket: this.stream,
+				servername
+			}, () => {
+				secureEstablished = true;
+				if (rejectUnauthorized) {
+					if (typeof servername === "string" && verifyIdentity) {
+						const cert = secureSocket.getPeerCertificate(true);
+						const serverIdentityCheckError = Tls.checkServerIdentity(servername, cert);
+						if (serverIdentityCheckError) {
+							onSecure(serverIdentityCheckError);
+							return;
+						}
+					}
+				}
+				onSecure();
+			});
+			secureSocket.on("error", (err) => {
+				if (secureEstablished) this._handleNetworkError(err);
+				else onSecure(err);
+			});
+			secureSocket.on("data", (data) => {
+				this.packetParser.execute(data);
+			});
+			this.stream = secureSocket;
+		}
+		protocolError(message, code) {
+			if (this._closing) return;
+			const err = new Error(message);
+			err.fatal = true;
+			err.code = code || "PROTOCOL_ERROR";
+			this.emit("error", err);
+		}
+		get state() {
+			if (this._fatalError || this._protocolError) return "error";
+			if (this._closing || this.stream && this.stream.destroyed) return "disconnected";
+			if (this.authorized) return "authenticated";
+			if (this._handshakePacket) return "connected";
+			if (this.stream && !this.stream.destroyed) return "protocol_handshake";
+			return "disconnected";
+		}
+		get fatalError() {
+			return this._fatalError;
+		}
+		handlePacket(packet) {
+			if (this._paused) {
+				this._paused_packets.push(packet);
+				return;
+			}
+			if (this.config.debug) {
+				if (packet) {
+					console.log(` raw: ${packet.buffer.slice(packet.offset, packet.offset + packet.length()).toString("hex")}`);
+					console.trace();
+					const commandName = this._command ? this._command._commandName : "(no command)";
+					const stateName = this._command ? this._command.stateName() : "(no command)";
+					console.log(`${this._internalId} ${this.connectionId} ==> ${commandName}#${stateName}(${[
+						packet.sequenceId,
+						packet.type(),
+						packet.length()
+					].join(",")})`);
+				}
+			}
+			if (!this._command) {
+				if (packet.peekByte() === 255) {
+					const error = Packets.Error.fromPacket(packet);
+					this.protocolError(error.message, error.code);
+				} else this.protocolError("Unexpected packet while no commands in the queue", "PROTOCOL_UNEXPECTED_PACKET");
+				this.close();
+				return;
+			}
+			if (packet) {
+				if (this.sequenceId !== packet.sequenceId) {
+					const err = /* @__PURE__ */ new Error(`Warning: got packets out of order. Expected ${this.sequenceId} but received ${packet.sequenceId}`);
+					err.expected = this.sequenceId;
+					err.received = packet.sequenceId;
+					this.emit("warn", err);
+					console.error(err.message);
+				}
+				this._bumpSequenceId(packet.numPackets);
+			}
+			try {
+				if (this._fatalError) return;
+				if (this._command.execute(packet, this)) {
+					this._command = this._commands.shift();
+					if (this._command) {
+						this.sequenceId = 0;
+						this.compressedSequenceId = 0;
+						this.handlePacket();
+					}
+				}
+			} catch (err) {
+				this._handleFatalError(err);
+				this.stream.destroy();
+			}
+		}
+		addCommand(cmd) {
+			if (this.config.debug) {
+				const commandName = cmd.constructor.name;
+				console.log(`Add command: ${commandName}`);
+				cmd._commandName = commandName;
+			}
+			if (!this._command) {
+				this._command = cmd;
+				this.handlePacket();
+			} else this._commands.push(cmd);
+			return cmd;
+		}
+		format(sql, values) {
+			if (typeof this.config.queryFormat === "function") return this.config.queryFormat.call(this, sql, values, this.config.timezone);
+			const opts = {
+				sql,
+				values
+			};
+			this._resolveNamedPlaceholders(opts);
+			return SqlString.format(opts.sql, opts.values, this.config.stringifyObjects, this.config.timezone);
+		}
+		escape(value) {
+			return SqlString.escape(value, false, this.config.timezone);
+		}
+		escapeId(value) {
+			return SqlString.escapeId(value, false);
+		}
+		raw(sql) {
+			return SqlString.raw(sql);
+		}
+		_resolveNamedPlaceholders(options) {
+			let unnamed;
+			if (this.config.namedPlaceholders || options.namedPlaceholders) {
+				if (Array.isArray(options.values)) return;
+				if (convertNamedPlaceholders === null) convertNamedPlaceholders = require_named_placeholders()();
+				unnamed = convertNamedPlaceholders(options.sql, options.values);
+				options.sql = unnamed[0];
+				options.values = unnamed[1];
+			}
+		}
+		query(sql, values, cb) {
+			let cmdQuery;
+			if (sql.constructor === Commands.Query) cmdQuery = sql;
+			else cmdQuery = BaseConnection.createQuery(sql, values, cb, this.config);
+			this._resolveNamedPlaceholders(cmdQuery);
+			cmdQuery.sql = this.format(cmdQuery.sql, cmdQuery.values !== void 0 ? cmdQuery.values : []);
+			return this.addCommand(cmdQuery);
+		}
+		pause() {
+			this._paused = true;
+			this.stream.pause();
+		}
+		resume() {
+			let packet;
+			this._paused = false;
+			while (packet = this._paused_packets.shift()) {
+				this.handlePacket(packet);
+				if (this._paused) return;
+			}
+			this.stream.resume();
+		}
+		prepare(options, cb) {
+			if (typeof options === "string") options = { sql: options };
+			return this.addCommand(new Commands.Prepare(options, cb));
+		}
+		unprepare(sql) {
+			let options = {};
+			if (typeof sql === "object") options = sql;
+			else options.sql = sql;
+			const key = BaseConnection.statementKey(options);
+			const stmt = this._statements.get(key);
+			if (stmt) {
+				this._statements.delete(key);
+				stmt.close();
+			}
+			return stmt;
+		}
+		execute(sql, values, cb) {
+			let options = { infileStreamFactory: this.config.infileStreamFactory };
+			if (typeof sql === "object") {
+				options = {
+					...options,
+					...sql,
+					sql: sql.sql,
+					values: sql.values
+				};
+				if (typeof values === "function") cb = values;
+				else options.values = options.values || values;
+			} else if (typeof values === "function") {
+				cb = values;
+				options.sql = sql;
+				options.values = void 0;
+			} else {
+				options.sql = sql;
+				options.values = values;
+			}
+			this._resolveNamedPlaceholders(options);
+			if (options.values) {
+				if (!Array.isArray(options.values)) throw new TypeError("Bind parameters must be array if namedPlaceholders parameter is not enabled");
+				options.values.forEach((val) => {
+					if (!Array.isArray(options.values)) throw new TypeError("Bind parameters must be array if namedPlaceholders parameter is not enabled");
+					if (val === void 0) throw new TypeError("Bind parameters must not contain undefined. To pass SQL NULL specify JS null");
+					if (typeof val === "function") throw new TypeError("Bind parameters must not contain function(s). To pass the body of a function as a string call .toString() first");
+				});
+			}
+			const executeCommand = new Commands.Execute(options, cb);
+			const prepareCommand = new Commands.Prepare(options, (err, stmt) => {
+				if (err) {
+					executeCommand.start = function() {
+						return null;
+					};
+					if (cb) cb(err);
+					else executeCommand.emit("error", err);
+					executeCommand.emit("end");
+					return;
+				}
+				executeCommand.statement = stmt;
+			});
+			this.addCommand(prepareCommand);
+			this.addCommand(executeCommand);
+			return executeCommand;
+		}
+		changeUser(options, callback) {
+			if (!callback && typeof options === "function") {
+				callback = options;
+				options = {};
+			}
+			const charsetNumber = options.charset ? ConnectionConfig.getCharsetNumber(options.charset) : this.config.charsetNumber;
+			return this.addCommand(new Commands.ChangeUser({
+				user: options.user || this.config.user,
+				password: options.password || options.password1 || this.config.password || this.config.password1,
+				password2: options.password2 || this.config.password2,
+				password3: options.password3 || this.config.password3,
+				passwordSha1: options.passwordSha1 || this.config.passwordSha1,
+				database: options.database || this.config.database,
+				timeout: options.timeout,
+				charsetNumber,
+				currentConfig: this.config
+			}, (err) => {
+				if (err) err.fatal = true;
+				if (callback) callback(err);
+			}));
+		}
+		beginTransaction(cb) {
+			return this.query("START TRANSACTION", cb);
+		}
+		commit(cb) {
+			return this.query("COMMIT", cb);
+		}
+		rollback(cb) {
+			return this.query("ROLLBACK", cb);
+		}
+		ping(cb) {
+			return this.addCommand(new Commands.Ping(cb));
+		}
+		_registerSlave(opts, cb) {
+			return this.addCommand(new Commands.RegisterSlave(opts, cb));
+		}
+		_binlogDump(opts, cb) {
+			return this.addCommand(new Commands.BinlogDump(opts, cb));
+		}
+		destroy() {
+			this.close();
+		}
+		close() {
+			if (this.connectTimeout) {
+				Timers.clearTimeout(this.connectTimeout);
+				this.connectTimeout = null;
+			}
+			this._closing = true;
+			this.stream.end();
+			this.addCommand = this._addCommandClosedState;
+		}
+		createBinlogStream(opts) {
+			let test = 1;
+			const stream = new Readable({ objectMode: true });
+			stream._read = function() {
+				return { data: test++ };
+			};
+			this._registerSlave(opts, () => {
+				const dumpCmd = this._binlogDump(opts);
+				dumpCmd.on("event", (ev) => {
+					stream.push(ev);
+				});
+				dumpCmd.on("eof", () => {
+					stream.push(null);
+					if (opts.flags && opts.flags & 1) this.close();
+				});
+			});
+			return stream;
+		}
+		connect(cb) {
+			if (!cb) return;
+			if (this._fatalError || this._protocolError) return cb(this._fatalError || this._protocolError);
+			if (this._handshakePacket) return cb(null, this);
+			let connectCalled = 0;
+			function callbackOnce(isErrorHandler) {
+				return function(param) {
+					if (!connectCalled) if (isErrorHandler) cb(param);
+					else cb(null, param);
+					connectCalled = 1;
+				};
+			}
+			this.once("error", callbackOnce(true));
+			this.once("connect", callbackOnce(false));
+		}
+		writeColumns(columns) {
+			this.writePacket(Packets.ResultSetHeader.toPacket(columns.length));
+			columns.forEach((column) => {
+				this.writePacket(Packets.ColumnDefinition.toPacket(column, this.serverConfig.encoding));
+			});
+			this.writeEof();
+		}
+		writeTextRow(column) {
+			this.writePacket(Packets.TextRow.toPacket(column, this.serverConfig.encoding));
+		}
+		writeBinaryRow(column) {
+			this.writePacket(Packets.BinaryRow.toPacket(column, this.serverConfig.encoding));
+		}
+		writeTextResult(rows, columns, binary = false) {
+			this.writeColumns(columns);
+			rows.forEach((row) => {
+				const arrayRow = new Array(columns.length);
+				columns.forEach((column) => {
+					arrayRow.push(row[column.name]);
+				});
+				if (binary) this.writeBinaryRow(arrayRow);
+				else this.writeTextRow(arrayRow);
+			});
+			this.writeEof();
+		}
+		writeEof(warnings, statusFlags) {
+			this.writePacket(Packets.EOF.toPacket(warnings, statusFlags));
+		}
+		writeOk(args) {
+			if (!args) args = { affectedRows: 0 };
+			this.writePacket(Packets.OK.toPacket(args, this.serverConfig.encoding));
+		}
+		writeError(args) {
+			const encoding = this.serverConfig ? this.serverConfig.encoding : "cesu8";
+			this.writePacket(Packets.Error.toPacket(args, encoding));
+		}
+		serverHandshake(args) {
+			this.serverConfig = args;
+			this.serverConfig.encoding = CharsetToEncoding[this.serverConfig.characterSet];
+			return this.addCommand(new Commands.ServerHandshake(args));
+		}
+		end(callback) {
+			if (this.config.isServer) {
+				this._closing = true;
+				const quitCmd$1 = new EventEmitter();
+				setImmediate(() => {
+					this.stream.end();
+					quitCmd$1.emit("end");
+				});
+				return quitCmd$1;
+			}
+			const quitCmd = this.addCommand(new Commands.Quit(callback));
+			this.addCommand = this._addCommandClosedState;
+			return quitCmd;
+		}
+		static createQuery(sql, values, cb, config) {
+			let options = {
+				rowsAsArray: config.rowsAsArray,
+				infileStreamFactory: config.infileStreamFactory
+			};
+			if (typeof sql === "object") {
+				options = {
+					...options,
+					...sql,
+					sql: sql.sql,
+					values: sql.values
+				};
+				if (typeof values === "function") cb = values;
+				else if (values !== void 0) options.values = values;
+			} else if (typeof values === "function") {
+				cb = values;
+				options.sql = sql;
+				options.values = void 0;
+			} else {
+				options.sql = sql;
+				options.values = values;
+			}
+			return new Commands.Query(options, cb);
+		}
+		static statementKey(options) {
+			return `${typeof options.nestTables}/${options.nestTables}/${options.rowsAsArray}${options.sql}`;
+		}
+	};
+	module.exports = BaseConnection;
+}) });
+
+//#endregion
+export default require_connection();
+
+export { require_connection };
+//# sourceMappingURL=connection.js.map