.

qwen/nodejs/node_modules/sequelize/lib/transaction.js

@@ -0,0 +1,177 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+class Transaction {
+  constructor(sequelize, options) {
+    this.sequelize = sequelize;
+    this.savepoints = [];
+    this._afterCommitHooks = [];
+    const generateTransactionId = this.sequelize.dialect.queryGenerator.generateTransactionId;
+    this.options = __spreadValues({
+      type: sequelize.options.transactionType,
+      isolationLevel: sequelize.options.isolationLevel,
+      readOnly: false
+    }, options);
+    this.parent = this.options.transaction;
+    if (this.parent) {
+      this.id = this.parent.id;
+      this.parent.savepoints.push(this);
+      this.name = `${this.id}-sp-${this.parent.savepoints.length}`;
+    } else {
+      this.id = this.name = generateTransactionId();
+    }
+    delete this.options.transaction;
+  }
+  async commit() {
+    if (this.finished) {
+      throw new Error(`Transaction cannot be committed because it has been finished with state: ${this.finished}`);
+    }
+    try {
+      await this.sequelize.getQueryInterface().commitTransaction(this, this.options);
+      this.cleanup();
+    } catch (e) {
+      console.warn(`Committing transaction ${this.id} failed with error ${JSON.stringify(e.message)}. We are killing its connection as it is now in an undetermined state.`);
+      await this.forceCleanup();
+      throw e;
+    } finally {
+      this.finished = "commit";
+      for (const hook of this._afterCommitHooks) {
+        await hook.apply(this, [this]);
+      }
+    }
+  }
+  async rollback() {
+    if (this.finished) {
+      throw new Error(`Transaction cannot be rolled back because it has been finished with state: ${this.finished}`);
+    }
+    if (!this.connection) {
+      throw new Error("Transaction cannot be rolled back because it never started");
+    }
+    try {
+      await this.sequelize.getQueryInterface().rollbackTransaction(this, this.options);
+      this.cleanup();
+    } catch (e) {
+      console.warn(`Rolling back transaction ${this.id} failed with error ${JSON.stringify(e.message)}. We are killing its connection as it is now in an undetermined state.`);
+      await this.forceCleanup();
+      throw e;
+    }
+  }
+  async prepareEnvironment(useCLS = true) {
+    let connectionPromise;
+    if (this.parent) {
+      connectionPromise = Promise.resolve(this.parent.connection);
+    } else {
+      const acquireOptions = { uuid: this.id };
+      if (this.options.readOnly) {
+        acquireOptions.type = "SELECT";
+      }
+      connectionPromise = this.sequelize.connectionManager.getConnection(acquireOptions);
+    }
+    let result;
+    const connection = await connectionPromise;
+    this.connection = connection;
+    this.connection.uuid = this.id;
+    try {
+      await this.begin();
+      result = await this.setDeferrable();
+    } catch (setupErr) {
+      try {
+        result = await this.rollback();
+      } finally {
+        throw setupErr;
+      }
+    }
+    if (useCLS && this.sequelize.constructor._cls) {
+      this.sequelize.constructor._cls.set("transaction", this);
+    }
+    return result;
+  }
+  async setDeferrable() {
+    if (this.options.deferrable) {
+      return await this.sequelize.getQueryInterface().deferConstraints(this, this.options);
+    }
+  }
+  async begin() {
+    const queryInterface = this.sequelize.getQueryInterface();
+    if (this.sequelize.dialect.supports.settingIsolationLevelDuringTransaction) {
+      await queryInterface.startTransaction(this, this.options);
+      return queryInterface.setIsolationLevel(this, this.options.isolationLevel, this.options);
+    }
+    await queryInterface.setIsolationLevel(this, this.options.isolationLevel, this.options);
+    return queryInterface.startTransaction(this, this.options);
+  }
+  cleanup() {
+    if (this.parent || this.connection.uuid === void 0) {
+      return;
+    }
+    this._clearCls();
+    this.sequelize.connectionManager.releaseConnection(this.connection);
+    this.connection.uuid = void 0;
+  }
+  async forceCleanup() {
+    if (this.parent || this.connection.uuid === void 0) {
+      return;
+    }
+    this._clearCls();
+    await this.sequelize.connectionManager.destroyConnection(this.connection);
+    this.connection.uuid = void 0;
+  }
+  _clearCls() {
+    const cls = this.sequelize.constructor._cls;
+    if (cls) {
+      if (cls.get("transaction") === this) {
+        cls.set("transaction", null);
+      }
+    }
+  }
+  afterCommit(fn) {
+    if (!fn || typeof fn !== "function") {
+      throw new Error('"fn" must be a function');
+    }
+    this._afterCommitHooks.push(fn);
+  }
+  static get TYPES() {
+    return {
+      DEFERRED: "DEFERRED",
+      IMMEDIATE: "IMMEDIATE",
+      EXCLUSIVE: "EXCLUSIVE"
+    };
+  }
+  static get ISOLATION_LEVELS() {
+    return {
+      READ_UNCOMMITTED: "READ UNCOMMITTED",
+      READ_COMMITTED: "READ COMMITTED",
+      REPEATABLE_READ: "REPEATABLE READ",
+      SERIALIZABLE: "SERIALIZABLE"
+    };
+  }
+  static get LOCK() {
+    return {
+      UPDATE: "UPDATE",
+      SHARE: "SHARE",
+      KEY_SHARE: "KEY SHARE",
+      NO_KEY_UPDATE: "NO KEY UPDATE"
+    };
+  }
+  get LOCK() {
+    return Transaction.LOCK;
+  }
+}
+module.exports = Transaction;
+module.exports.Transaction = Transaction;
+module.exports.default = Transaction;
+//# sourceMappingURL=transaction.js.map