@nocobase/database 0.7.0-alpha.9 → 0.7.1-alpha.6

package/lib/transaction-decorator.js

@@ -1,70 +1,83 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transactionWrapperBuilder = void 0;
-const lodash_1 = __importDefault(require("lodash"));
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transactionWrapperBuilder = transactionWrapperBuilder;
+
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
 function transactionWrapperBuilder(transactionGenerator) {
-    return function transaction(transactionInjector) {
-        return (target, name, descriptor) => {
-            const oldValue = descriptor.value;
-            descriptor.value = function () {
-                return __awaiter(this, arguments, void 0, function* () {
-                    let transaction;
-                    let newTransaction = false;
-                    if (arguments.length > 0 && typeof arguments[0] === 'object') {
-                        transaction = arguments[0]['transaction'];
-                    }
-                    if (!transaction) {
-                        transaction = yield transactionGenerator.apply(this);
-                        newTransaction = true;
-                    }
-                    // 需要将 newTransaction 注入到被装饰函数参数内
-                    if (newTransaction) {
-                        try {
-                            let callArguments;
-                            if (lodash_1.default.isPlainObject(arguments[0])) {
-                                callArguments = Object.assign(Object.assign({}, arguments[0]), { transaction });
-                            }
-                            else if (transactionInjector) {
-                                callArguments = transactionInjector(arguments, transaction);
-                            }
-                            else if (lodash_1.default.isNull(arguments[0]) || lodash_1.default.isUndefined(arguments[0])) {
-                                callArguments = {
-                                    transaction,
-                                };
-                            }
-                            else {
-                                throw new Error(`please provide transactionInjector for ${name} call`);
-                            }
-                            const results = yield oldValue.apply(this, [callArguments]);
-                            yield transaction.commit();
-                            return results;
-                        }
-                        catch (err) {
-                            console.error({ err });
-                            yield transaction.rollback();
-                            throw err;
-                        }
-                    }
-                    else {
-                        return oldValue.apply(this, arguments);
-                    }
-                });
-            };
-            return descriptor;
-        };
+  return function transaction(transactionInjector) {
+    return (target, name, descriptor) => {
+      const oldValue = descriptor.value;
+      descriptor.value = /*#__PURE__*/_asyncToGenerator(function* () {
+        let transaction;
+        let newTransaction = false;
+
+        if (arguments.length > 0 && typeof arguments[0] === 'object') {
+          transaction = arguments[0]['transaction'];
+        }
+
+        if (!transaction) {
+          transaction = yield transactionGenerator.apply(this);
+          newTransaction = true;
+        } // 需要将 newTransaction 注入到被装饰函数参数内
+
+
+        if (newTransaction) {
+          try {
+            let callArguments;
+
+            if (_lodash().default.isPlainObject(arguments[0])) {
+              callArguments = _objectSpread(_objectSpread({}, arguments[0]), {}, {
+                transaction
+              });
+            } else if (transactionInjector) {
+              callArguments = transactionInjector(arguments, transaction);
+            } else if (_lodash().default.isNull(arguments[0]) || _lodash().default.isUndefined(arguments[0])) {
+              callArguments = {
+                transaction
+              };
+            } else {
+              throw new Error(`please provide transactionInjector for ${name} call`);
+            }
+
+            const results = yield oldValue.apply(this, [callArguments]);
+            yield transaction.commit();
+            return results;
+          } catch (err) {
+            console.error({
+              err
+            });
+            yield transaction.rollback();
+            throw err;
+          }
+        } else {
+          return oldValue.apply(this, arguments);
+        }
+      });
+      return descriptor;
     };
-}
-exports.transactionWrapperBuilder = transactionWrapperBuilder;
-//# sourceMappingURL=transaction-decorator.js.map
+  };
+}

package/lib/update-associations.d.ts

@@ -1,6 +1,5 @@
 import { Association, BelongsToMany, Hookable, Transactionable } from 'sequelize';
 import { Model } from './model';
-import { TransactionAble } from './repository';
 export declare function modelAssociations(instance: Model): {
     [key: string]: Association<import("sequelize").Model<any, any>, import("sequelize").Model<any, any>>;
 };
@@ -9,7 +8,7 @@ export declare function modelAssociationByKey(instance: Model, key: string): Ass
 declare type UpdateValue = {
     [key: string]: any;
 };
-interface UpdateOptions extends TransactionAble {
+interface UpdateOptions extends Transactionable {
     filter?: any;
     filterByTk?: number | string;
     whitelist?: string[];