@nocobase/database 0.7.0-alpha.8 → 0.7.0-alpha.80

package/lib/relation-repository/relation-repository.js

@@ -1,100 +1,160 @@
 "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.RelationRepository = exports.transaction = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const filter_parser_1 = __importDefault(require("../filter-parser"));
-const options_parser_1 = require("../options-parser");
-const transaction_decorator_1 = require("../transaction-decorator");
-const update_associations_1 = require("../update-associations");
-const update_guard_1 = require("../update-guard");
-exports.transaction = (0, transaction_decorator_1.transactionWrapperBuilder)(function () {
-    return this.sourceCollection.model.sequelize.transaction();
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transaction = exports.RelationRepository = void 0;
+
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+var _filterParser = _interopRequireDefault(require("../filter-parser"));
+
+var _optionsParser = require("../options-parser");
+
+var _transactionDecorator = require("../transaction-decorator");
+
+var _updateAssociations = require("../update-associations");
+
+var _updateGuard = require("../update-guard");
+
+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); }); }; }
+
+const transaction = (0, _transactionDecorator.transactionWrapperBuilder)(function () {
+  return this.sourceCollection.model.sequelize.transaction();
 });
+exports.transaction = transaction;
+
 class RelationRepository {
-    constructor(sourceCollection, association, sourceKeyValue) {
-        this.db = sourceCollection.context.database;
-        this.sourceCollection = sourceCollection;
-        this.sourceKeyValue = sourceKeyValue;
-        this.associationName = association;
-        this.association = this.sourceCollection.model.associations[association];
-        this.associationField = this.sourceCollection.getField(association);
-        this.targetModel = this.association.target;
-        this.targetCollection = this.sourceCollection.context.database.modelCollection.get(this.targetModel);
-    }
-    targetKey() {
-        return this.associationField.targetKey;
-    }
-    accessors() {
-        return this.association.accessors;
-    }
-    create(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const createAccessor = this.accessors().create;
-            const guard = update_guard_1.UpdateGuard.fromOptions(this.targetModel, options);
-            const values = options.values;
-            const sourceModel = yield this.getSourceModel();
-            const instance = yield sourceModel[createAccessor](guard.sanitize(options.values), options);
-            yield (0, update_associations_1.updateAssociations)(instance, values, options);
-            if (options.hooks !== false) {
-                yield this.db.emitAsync(`${this.targetCollection.name}.afterCreateWithAssociations`, instance, options);
-                const eventName = `${this.targetCollection.name}.afterSaveWithAssociations`;
-                yield this.db.emitAsync(eventName, instance, options);
-            }
-            return instance;
-        });
-    }
-    getSourceModel(transaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.sourceInstance) {
-                this.sourceInstance = yield this.sourceCollection.model.findOne({
-                    where: {
-                        [this.associationField.sourceKey]: this.sourceKeyValue,
-                    },
-                });
-            }
-            return this.sourceInstance;
-        });
-    }
-    buildQueryOptions(options) {
-        const parser = new options_parser_1.OptionsParser(options, {
-            collection: this.targetCollection,
-            targetKey: this.targetKey(),
+  constructor(sourceCollection, association, sourceKeyValue) {
+    this.sourceCollection = void 0;
+    this.association = void 0;
+    this.targetModel = void 0;
+    this.targetCollection = void 0;
+    this.associationName = void 0;
+    this.associationField = void 0;
+    this.sourceKeyValue = void 0;
+    this.sourceInstance = void 0;
+    this.db = void 0;
+    this.db = sourceCollection.context.database;
+    this.sourceCollection = sourceCollection;
+    this.sourceKeyValue = sourceKeyValue;
+    this.associationName = association;
+    this.association = this.sourceCollection.model.associations[association];
+    this.associationField = this.sourceCollection.getField(association);
+    this.targetModel = this.association.target;
+    this.targetCollection = this.sourceCollection.context.database.modelCollection.get(this.targetModel);
+  }
+
+  targetKey() {
+    return this.associationField.targetKey;
+  }
+
+  accessors() {
+    return this.association.accessors;
+  }
+
+  create(options) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const createAccessor = _this.accessors().create;
+
+      const guard = _updateGuard.UpdateGuard.fromOptions(_this.targetModel, options);
+
+      const values = options.values;
+      const transaction = yield _this.getTransaction(options);
+      const sourceModel = yield _this.getSourceModel(transaction);
+      const instance = yield sourceModel[createAccessor](guard.sanitize(options.values), _objectSpread(_objectSpread({}, options), {}, {
+        transaction
+      }));
+      yield (0, _updateAssociations.updateAssociations)(instance, values, _objectSpread(_objectSpread({}, options), {}, {
+        transaction
+      }));
+
+      if (options.hooks !== false) {
+        yield _this.db.emitAsync(`${_this.targetCollection.name}.afterCreateWithAssociations`, instance, _objectSpread(_objectSpread({}, options), {}, {
+          transaction
+        }));
+        const eventName = `${_this.targetCollection.name}.afterSaveWithAssociations`;
+        yield _this.db.emitAsync(eventName, instance, _objectSpread(_objectSpread({}, options), {}, {
+          transaction
+        }));
+      }
+
+      return instance;
+    })();
+  }
+
+  getSourceModel(transaction) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      if (!_this2.sourceInstance) {
+        _this2.sourceInstance = yield _this2.sourceCollection.model.findOne({
+          where: {
+            [_this2.associationField.sourceKey]: _this2.sourceKeyValue
+          },
+          transaction
         });
-        const params = parser.toSequelizeParams();
-        return Object.assign(Object.assign({}, options), params);
-    }
-    parseFilter(filter, options) {
-        const parser = new filter_parser_1.default(filter, {
-            collection: this.targetCollection,
-            app: {
-                ctx: options === null || options === void 0 ? void 0 : options.context,
-            },
-        });
-        return parser.toSequelizeParams();
-    }
-    getTransaction(options, autoGen = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (lodash_1.default.isPlainObject(options) && options.transaction) {
-                return options.transaction;
-            }
-            if (autoGen) {
-                return yield this.sourceCollection.model.sequelize.transaction();
-            }
-            return null;
-        });
-    }
+      }
+
+      return _this2.sourceInstance;
+    })();
+  }
+
+  buildQueryOptions(options) {
+    const parser = new _optionsParser.OptionsParser(options, {
+      collection: this.targetCollection,
+      targetKey: this.targetKey()
+    });
+    const params = parser.toSequelizeParams();
+    return _objectSpread(_objectSpread({}, options), params);
+  }
+
+  parseFilter(filter, options) {
+    const parser = new _filterParser.default(filter, {
+      collection: this.targetCollection,
+      app: {
+        ctx: options === null || options === void 0 ? void 0 : options.context
+      }
+    });
+    return parser.toSequelizeParams();
+  }
+
+  getTransaction(options, autoGen = false) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_lodash().default.isPlainObject(options) && options.transaction) {
+        return options.transaction;
+      }
+
+      if (autoGen) {
+        return yield _this3.sourceCollection.model.sequelize.transaction();
+      }
+
+      return null;
+    })();
+  }
+
 }
-exports.RelationRepository = RelationRepository;
-//# sourceMappingURL=relation-repository.js.map
+
+exports.RelationRepository = RelationRepository;

package/lib/relation-repository/single-relation-repository.d.ts

@@ -1,22 +1,22 @@
-import { SingleAssociationAccessors } from 'sequelize';
+import { SingleAssociationAccessors, Transactionable } from 'sequelize';
 import { Model } from '../model';
-import { Appends, Except, Fields, Filter, TargetKey, TransactionAble, UpdateOptions } from '../repository';
+import { Appends, Except, Fields, Filter, TargetKey, UpdateOptions } from '../repository';
 import { RelationRepository } from './relation-repository';
-export interface SingleRelationFindOption extends TransactionAble {
+export interface SingleRelationFindOption extends Transactionable {
     fields?: Fields;
     except?: Except;
     appends?: Appends;
     filter?: Filter;
 }
-interface SetOption extends TransactionAble {
+interface SetOption extends Transactionable {
     tk?: TargetKey;
 }
 export declare abstract class SingleRelationRepository extends RelationRepository {
-    remove(options?: TransactionAble): Promise<void>;
+    remove(options?: Transactionable): Promise<void>;
     set(options: TargetKey | SetOption): Promise<void>;
     find(options?: SingleRelationFindOption): Promise<Model<any>>;
     findOne(options?: SingleRelationFindOption): Promise<Model<any>>;
-    destroy(options?: TransactionAble): Promise<Boolean>;
+    destroy(options?: Transactionable): Promise<Boolean>;
     update(options: UpdateOptions): Promise<any>;
     accessors(): SingleAssociationAccessors;
 }

package/lib/relation-repository/single-relation-repository.js

@@ -1,103 +1,142 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-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 });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.SingleRelationRepository = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const update_associations_1 = require("../update-associations");
-const relation_repository_1 = require("./relation-repository");
-class SingleRelationRepository extends relation_repository_1.RelationRepository {
-    remove(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const transaction = yield this.getTransaction(options);
-            const sourceModel = yield this.getSourceModel(transaction);
-            return yield sourceModel[this.accessors().set](null, {
-                transaction,
-            });
-        });
-    }
-    set(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const transaction = yield this.getTransaction(options);
-            let handleKey = lodash_1.default.isPlainObject(options) ? options.tk : options;
-            const sourceModel = yield this.getSourceModel(transaction);
-            return yield sourceModel[this.accessors().set](handleKey, {
-                transaction,
-            });
-        });
-    }
-    find(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const transaction = yield this.getTransaction(options);
-            const findOptions = this.buildQueryOptions(Object.assign({}, options));
-            const getAccessor = this.accessors().get;
-            const sourceModel = yield this.getSourceModel(transaction);
-            return yield sourceModel[getAccessor](Object.assign(Object.assign({}, findOptions), { transaction }));
-        });
-    }
-    findOne(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.find(options);
-        });
-    }
-    destroy(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const transaction = yield this.getTransaction(options);
-            const target = yield this.find({
-                transaction,
-            });
-            yield target.destroy({
-                transaction,
-            });
-            return true;
-        });
-    }
-    update(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const transaction = yield this.getTransaction(options);
-            const target = yield this.find({
-                transaction,
-            });
-            yield (0, update_associations_1.updateModelByValues)(target, options === null || options === void 0 ? void 0 : options.values, Object.assign(Object.assign({}, lodash_1.default.omit(options, 'values')), { transaction }));
-            return target;
-        });
-    }
-    accessors() {
-        return super.accessors();
-    }
+
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+var _updateAssociations = require("../update-associations");
+
+var _relationRepository = require("./relation-repository");
+
+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); }); }; }
+
+var __decorate = void 0 && (void 0).__decorate || function (decorators, target, key, desc) {
+  var c = arguments.length,
+      r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
+      d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+class SingleRelationRepository extends _relationRepository.RelationRepository {
+  remove(options) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const transaction = yield _this.getTransaction(options);
+      const sourceModel = yield _this.getSourceModel(transaction);
+      return yield sourceModel[_this.accessors().set](null, {
+        transaction
+      });
+    })();
+  }
+
+  set(options) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      const transaction = yield _this2.getTransaction(options);
+      let handleKey = _lodash().default.isPlainObject(options) ? options.tk : options;
+      const sourceModel = yield _this2.getSourceModel(transaction);
+      return yield sourceModel[_this2.accessors().set](handleKey, {
+        transaction
+      });
+    })();
+  }
+
+  find(options) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      const transaction = yield _this3.getTransaction(options);
+
+      const findOptions = _this3.buildQueryOptions(_objectSpread({}, options));
+
+      const getAccessor = _this3.accessors().get;
+
+      const sourceModel = yield _this3.getSourceModel(transaction);
+      return yield sourceModel[getAccessor](_objectSpread(_objectSpread({}, findOptions), {}, {
+        transaction
+      }));
+    })();
+  }
+
+  findOne(options) {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      return _this4.find(options);
+    })();
+  }
+
+  destroy(options) {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      const transaction = yield _this5.getTransaction(options);
+      const target = yield _this5.find({
+        transaction
+      });
+      yield target.destroy({
+        transaction
+      });
+      return true;
+    })();
+  }
+
+  update(options) {
+    var _this6 = this;
+
+    return _asyncToGenerator(function* () {
+      const transaction = yield _this6.getTransaction(options);
+      const target = yield _this6.find({
+        transaction
+      });
+      yield (0, _updateAssociations.updateModelByValues)(target, options === null || options === void 0 ? void 0 : options.values, _objectSpread(_objectSpread({}, _lodash().default.omit(options, 'values')), {}, {
+        transaction
+      }));
+      return target;
+    })();
+  }
+
+  accessors() {
+    return super.accessors();
+  }
+
 }
-__decorate([
-    (0, relation_repository_1.transaction)()
-], SingleRelationRepository.prototype, "remove", null);
-__decorate([
-    (0, relation_repository_1.transaction)((args, transaction) => {
-        return {
-            tk: args[0],
-            transaction,
-        };
-    })
-], SingleRelationRepository.prototype, "set", null);
-__decorate([
-    (0, relation_repository_1.transaction)()
-], SingleRelationRepository.prototype, "destroy", null);
-__decorate([
-    (0, relation_repository_1.transaction)()
-], SingleRelationRepository.prototype, "update", null);
+
 exports.SingleRelationRepository = SingleRelationRepository;
-//# sourceMappingURL=single-relation-repository.js.map
+
+__decorate([(0, _relationRepository.transaction)()], SingleRelationRepository.prototype, "remove", null);
+
+__decorate([(0, _relationRepository.transaction)((args, transaction) => {
+  return {
+    tk: args[0],
+    transaction
+  };
+})], SingleRelationRepository.prototype, "set", null);
+
+__decorate([(0, _relationRepository.transaction)()], SingleRelationRepository.prototype, "destroy", null);
+
+__decorate([(0, _relationRepository.transaction)()], SingleRelationRepository.prototype, "update", null);

package/lib/relation-repository/types.js

@@ -1,3 +1,5 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/repository.d.ts

@@ -1,4 +1,4 @@
-import { Association, BulkCreateOptions, CreateOptions as SequelizeCreateOptions, DestroyOptions as SequelizeDestroyOptions, FindAndCountOptions as SequelizeAndCountOptions, FindOptions as SequelizeFindOptions, ModelCtor, Transaction, UpdateOptions as SequelizeUpdateOptions } from 'sequelize';
+import { Association, BulkCreateOptions, CreateOptions as SequelizeCreateOptions, DestroyOptions as SequelizeDestroyOptions, FindAndCountOptions as SequelizeAndCountOptions, FindOptions as SequelizeFindOptions, ModelCtor, Transactionable, UpdateOptions as SequelizeUpdateOptions } from 'sequelize';
 import { Collection } from './collection';
 import { Database } from './database';
 import { Model } from './model';
@@ -12,9 +12,7 @@ export interface IRepository {
 interface CreateManyOptions extends BulkCreateOptions {
     records: Values[];
 }
-export interface TransactionAble {
-    transaction?: Transaction;
-}
+export { Transactionable } from 'sequelize';
 export interface FilterAble {
     filter: Filter;
 }
@@ -29,7 +27,7 @@ export declare type WhiteList = string[];
 export declare type BlackList = string[];
 export declare type AssociationKeysToBeUpdate = string[];
 export declare type Values = any;
-export interface CountOptions extends Omit<SequelizeCreateOptions, 'distinct' | 'where' | 'include'>, TransactionAble {
+export interface CountOptions extends Omit<SequelizeCreateOptions, 'distinct' | 'where' | 'include'>, Transactionable {
     fields?: Fields;
     filter?: Filter;
 }
@@ -38,7 +36,7 @@ export interface FilterByTk {
 }
 export interface FindOptions extends SequelizeFindOptions, CommonFindOptions, FilterByTk {
 }
-export interface CommonFindOptions {
+export interface CommonFindOptions extends Transactionable {
     filter?: Filter;
     fields?: Fields;
     appends?: Appends;
@@ -162,4 +160,3 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
     };
     protected getTransaction(options: any, autoGen?: boolean): Promise<any>;
 }
-export {};