@nocobase/database 0.8.0-alpha.8 → 0.8.1-alpha.3

package/lib/options-parser.js

@@ -143,6 +143,10 @@ class OptionsParser {
     return filterParams;
   }
 
+  inheritFromSubQuery() {
+    return [_sequelize().Sequelize.literal(`(select relname from pg_class where pg_class.oid = "${this.collection.name}".tableoid)`), '__tableName'];
+  }
+
   parseFields(filterParams) {
     var _this$options3, _this$options4, _this$options5;
 
@@ -153,6 +157,10 @@ class OptionsParser {
       exclude: []
     }; // out put all fields by default
 
+    if (this.collection.isParent()) {
+      attributes.include.push(this.inheritFromSubQuery());
+    }
+
     if ((_this$options4 = this.options) === null || _this$options4 === void 0 ? void 0 : _this$options4.fields) {
       // 将fields拆分为 attributes 和 appends
       var _iterator2 = _createForOfIteratorHelper(this.options.fields),
@@ -167,7 +175,14 @@ class OptionsParser {
             appends.push(field);
           } else {
             // field is model attribute, change attributes to array type
-            if (!Array.isArray(attributes)) attributes = [];
+            if (!Array.isArray(attributes)) {
+              attributes = [];
+
+              if (this.collection.isParent()) {
+                attributes.push(this.inheritFromSubQuery());
+              }
+            }
+
             attributes.push(field);
           }
         }

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

@@ -1,4 +1,4 @@
-import { Association, ModelCtor, Transaction } from 'sequelize';
+import { Association, ModelStatic, Transaction } from 'sequelize';
 import { Collection } from '../collection';
 import Database from '../database';
 import { RelationField } from '../fields/relation-field';
@@ -8,7 +8,7 @@ export declare const transaction: (transactionInjector?: any) => (target: any, n
 export declare abstract class RelationRepository {
     sourceCollection: Collection;
     association: Association;
-    targetModel: ModelCtor<any>;
+    targetModel: ModelStatic<any>;
     targetCollection: Collection;
     associationName: string;
     associationField: RelationField;

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

@@ -17,10 +17,10 @@ function _lodash() {
 
 var _updateAssociations = require("../update-associations");
 
-var _relationRepository = require("./relation-repository");
-
 var _utils = require("../utils");
 
+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; }

package/lib/repository.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
-import { Association, BulkCreateOptions, CountOptions as SequelizeCountOptions, CreateOptions as SequelizeCreateOptions, DestroyOptions as SequelizeDestroyOptions, FindAndCountOptions as SequelizeAndCountOptions, FindOptions as SequelizeFindOptions, ModelCtor, Transactionable, UpdateOptions as SequelizeUpdateOptions } from 'sequelize';
-import { WhereOperators } from 'sequelize/types/lib/model';
+import { Association, BulkCreateOptions, CountOptions as SequelizeCountOptions, CreateOptions as SequelizeCreateOptions, DestroyOptions as SequelizeDestroyOptions, FindAndCountOptions as SequelizeAndCountOptions, FindOptions as SequelizeFindOptions, ModelStatic, Transactionable, UpdateOptions as SequelizeUpdateOptions, WhereOperators } from 'sequelize';
 import { Collection } from './collection';
 import { Database } from './database';
+import { ArrayFieldRepository } from './field-repository/array-field-repository';
 import { Model } from './model';
 import operators from './operators';
 import { BelongsToManyRepository } from './relation-repository/belongs-to-many-repository';
@@ -46,10 +46,10 @@ 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<SequelizeCountOptions, 'distinct' | 'where' | 'include'>, Transactionable {
+export declare type CountOptions = Omit<SequelizeCountOptions, 'distinct' | 'where' | 'include'> & Transactionable & {
     filter?: Filter;
     context?: any;
-}
+} & FilterByTk;
 export interface FilterByTk {
     filterByTk?: TargetKey;
 }
@@ -86,15 +86,21 @@ export interface UpdateOptions extends Omit<SequelizeUpdateOptions, 'where'> {
     updateAssociationValues?: AssociationKeysToBeUpdate;
     context?: any;
 }
+interface UpdateManyOptions extends UpdateOptions {
+    records: Values[];
+}
 declare class RelationRepositoryBuilder<R extends RelationRepository> {
     collection: Collection;
     associationName: string;
-    association: Association;
+    association: Association | {
+        associationType: string;
+    };
     builderMap: {
         HasOne: typeof HasOneRepository;
         BelongsTo: typeof BelongsToRepository;
         BelongsToMany: typeof BelongsToManyRepository;
         HasMany: typeof HasManyRepository;
+        ArrayField: typeof ArrayFieldRepository;
     };
     constructor(collection: Collection, associationName: string);
     protected builder(): {
@@ -102,13 +108,14 @@ declare class RelationRepositoryBuilder<R extends RelationRepository> {
         BelongsTo: typeof BelongsToRepository;
         BelongsToMany: typeof BelongsToManyRepository;
         HasMany: typeof HasManyRepository;
+        ArrayField: typeof ArrayFieldRepository;
     };
     of(id: string | number): R;
 }
 export declare class Repository<TModelAttributes extends {} = any, TCreationAttributes extends {} = TModelAttributes> implements IRepository {
     database: Database;
     collection: Collection;
-    model: ModelCtor<Model>;
+    model: ModelStatic<Model>;
     constructor(collection: Collection);
     /**
      * return count by filter
@@ -118,7 +125,7 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
      * find
      * @param options
      */
-    find(options?: FindOptions): Promise<Model<any, any>[]>;
+    find(options?: FindOptions): Promise<any>;
     /**
      * find and count
      * @param options
@@ -134,7 +141,7 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
      *
      * @param options
      */
-    findOne(options?: FindOneOptions): Promise<Model<any, any>>;
+    findOne(options?: FindOneOptions): Promise<any>;
     /**
      * Save instance to database
      *
@@ -157,13 +164,14 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
      */
     update(options: UpdateOptions & {
         forceUpdate?: boolean;
-    }): Promise<Model<any, any>[]>;
+    }): Promise<any>;
+    updateMany(options: UpdateManyOptions): Promise<any[]>;
     destroy(options?: TargetKey | TargetKey[] | DestroyOptions): any;
     /**
      * @param association target association
      */
     relation<R extends RelationRepository>(association: string): RelationRepositoryBuilder<R>;
-    protected buildQueryOptions(options: any): any;
+    buildQueryOptions(options: any): any;
     protected parseFilter(filter: Filter, options?: any): {
         where?: undefined;
         include?: undefined;

package/lib/repository.js

@@ -29,6 +29,10 @@ var _mustHaveFilterDecorator = _interopRequireDefault(require("./decorators/must
 
 var _transactionDecorator = require("./decorators/transaction-decorator");
 
+var _arrayFieldRepository = require("./field-repository/array-field-repository");
+
+var _fields = require("./fields");
+
 var _filterParser = _interopRequireDefault(require("./filter-parser"));
 
 var _optionsParser = require("./options-parser");
@@ -92,11 +96,22 @@ class RelationRepositoryBuilder {
       HasOne: _hasoneRepository.HasOneRepository,
       BelongsTo: _belongsToRepository.BelongsToRepository,
       BelongsToMany: _belongsToManyRepository.BelongsToManyRepository,
-      HasMany: _hasmanyRepository.HasManyRepository
+      HasMany: _hasmanyRepository.HasManyRepository,
+      ArrayField: _arrayFieldRepository.ArrayFieldRepository
     };
     this.collection = collection;
     this.associationName = associationName;
     this.association = this.collection.model.associations[this.associationName];
+
+    if (!this.association) {
+      const field = collection.getField(associationName);
+
+      if (field && field instanceof _fields.ArrayField) {
+        this.association = {
+          associationType: 'ArrayField'
+        };
+      }
+    }
   }
 
   builder() {
@@ -128,6 +143,8 @@ class Repository {
     var _this = this;
 
     return _asyncToGenerator(function* () {
+      var _queryOptions$include;
+
       let options = countOptions ? _lodash().default.clone(countOptions) : {};
       const transaction = yield _this.getTransaction(options);
 
@@ -135,10 +152,26 @@ class Repository {
         options = _objectSpread(_objectSpread({}, options), _this.parseFilter(countOptions.filter, countOptions));
       }
 
-      const count = yield _this.collection.model.count(_objectSpread(_objectSpread({}, options), {}, {
-        distinct: true,
+      if (countOptions === null || countOptions === void 0 ? void 0 : countOptions.filterByTk) {
+        options['where'] = {
+          [_sequelize().Op.and]: [options['where'] || {}, {
+            [_this.collection.filterTargetKey]: options.filterByTk
+          }]
+        };
+      }
+
+      const queryOptions = _objectSpread(_objectSpread({}, options), {}, {
+        distinct: Boolean(_this.collection.model.primaryKeyAttribute)
+      });
+
+      if (((_queryOptions$include = queryOptions.include) === null || _queryOptions$include === void 0 ? void 0 : _queryOptions$include.length) === 0) {
+        delete queryOptions.include;
+      }
+
+      const count = yield _this.collection.model.count(_objectSpread(_objectSpread({}, queryOptions), {}, {
         transaction
-      }));
+      })); // @ts-ignore
+
       return count;
     })();
   }
@@ -159,6 +192,8 @@ class Repository {
         subQuery: false
       }, _this2.buildQueryOptions(options));
 
+      let rows;
+
       if (opts.include && opts.include.length > 0) {
         // @ts-ignore
         const primaryKeyField = model.primaryKeyField || model.primaryKeyAttribute;
@@ -166,7 +201,12 @@ class Repository {
           includeIgnoreAttributes: false,
           attributes: [primaryKeyField],
           group: `${model.name}.${primaryKeyField}`,
-          transaction
+          transaction,
+          include: opts.include.filter(include => {
+            var _JSON$stringify;
+
+            return Object.keys(include.where || {}).length > 0 || ((_JSON$stringify = JSON.stringify(opts === null || opts === void 0 ? void 0 : opts.filter)) === null || _JSON$stringify === void 0 ? void 0 : _JSON$stringify.includes(include.association));
+          })
         }))).map(row => {
           return {
             row,
@@ -178,31 +218,64 @@ class Repository {
           return [];
         }
 
+        const templateModel = yield model.findOne(_objectSpread(_objectSpread({}, opts), {}, {
+          includeIgnoreAttributes: false,
+          attributes: [primaryKeyField],
+          group: `${model.name}.${primaryKeyField}`,
+          transaction,
+          limit: 1,
+          offset: 0
+        }));
         const where = {
           [primaryKeyField]: {
             [_sequelize().Op.in]: ids.map(id => id['pk'])
           }
         };
-        return yield (0, _utils.handleAppendsQuery)({
+        rows = yield (0, _utils.handleAppendsQuery)({
           queryPromises: opts.include.map(include => {
-            return model.findAll(_objectSpread(_objectSpread({}, (0, _lodash().omit)(opts, ['limit', 'offset'])), {}, {
+            const options = _objectSpread(_objectSpread({}, (0, _lodash().omit)(opts, ['limit', 'offset'])), {}, {
               include: include,
               where,
               transaction
-            })).then(rows => {
+            });
+
+            return model.findAll(options).then(rows => {
               return {
                 rows,
                 include
               };
             });
           }),
-          templateModel: ids[0].row
+          templateModel: templateModel
         });
+      } else {
+        rows = yield model.findAll(_objectSpread(_objectSpread({}, opts), {}, {
+          transaction
+        }));
       }
 
-      return yield model.findAll(_objectSpread(_objectSpread({}, opts), {}, {
-        transaction
-      }));
+      if (_this2.collection.isParent()) {
+        var _iterator = _createForOfIteratorHelper(rows),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            const row = _step.value;
+
+            const rowCollectionName = _this2.database.tableNameCollectionMap.get(row.get('__tableName')).name;
+
+            row.set('__collection', rowCollectionName, {
+              raw: true
+            });
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+
+      return rows;
     })();
   }
   /**
@@ -318,12 +391,12 @@ class Repository {
       const records = options.records;
       const instances = [];
 
-      var _iterator = _createForOfIteratorHelper(records),
-          _step;
+      var _iterator2 = _createForOfIteratorHelper(records),
+          _step2;
 
       try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          const values = _step.value;
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          const values = _step2.value;
           const instance = yield _this6.create({
             values,
             transaction
@@ -331,9 +404,9 @@ class Repository {
           instances.push(instance);
         }
       } catch (err) {
-        _iterator.e(err);
+        _iterator2.e(err);
       } finally {
-        _iterator.f();
+        _iterator2.f();
       }
 
       return instances;
@@ -351,6 +424,12 @@ class Repository {
     var _this7 = this;
 
     return _asyncToGenerator(function* () {
+      if (Array.isArray(options.values)) {
+        return _this7.updateMany(_objectSpread(_objectSpread({}, options), {}, {
+          records: options.values
+        }));
+      }
+
       const transaction = yield _this7.getTransaction(options);
 
       const guard = _updateGuard.UpdateGuard.fromOptions(_this7.model, options);
@@ -363,30 +442,30 @@ class Repository {
         transaction
       }));
 
-      var _iterator2 = _createForOfIteratorHelper(instances),
-          _step2;
+      var _iterator3 = _createForOfIteratorHelper(instances),
+          _step3;
 
       try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          const instance = _step2.value;
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          const instance = _step3.value;
           yield (0, _updateAssociations.updateModelByValues)(instance, values, _objectSpread(_objectSpread({}, options), {}, {
             sanitized: true,
             transaction
           }));
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator3.e(err);
       } finally {
-        _iterator2.f();
+        _iterator3.f();
       }
 
       if (options.hooks !== false) {
-        var _iterator3 = _createForOfIteratorHelper(instances),
-            _step3;
+        var _iterator4 = _createForOfIteratorHelper(instances),
+            _step4;
 
         try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            const instance = _step3.value;
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            const instance = _step4.value;
             yield _this7.database.emitAsync(`${_this7.collection.name}.afterUpdateWithAssociations`, instance, _objectSpread(_objectSpread({}, options), {}, {
               transaction
             }));
@@ -396,9 +475,9 @@ class Repository {
             instance.clearChangedWithAssociations();
           }
         } catch (err) {
-          _iterator3.e(err);
+          _iterator4.e(err);
         } finally {
-          _iterator3.f();
+          _iterator4.f();
         }
       }
 
@@ -406,12 +485,49 @@ class Repository {
     })();
   }
 
-  destroy(options) {
+  updateMany(options) {
     var _this8 = this;
 
     return _asyncToGenerator(function* () {
       const transaction = yield _this8.getTransaction(options);
-      const modelFilterKey = _this8.collection.filterTargetKey;
+      const records = options.records;
+      const instances = [];
+
+      var _iterator5 = _createForOfIteratorHelper(records),
+          _step5;
+
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          const values = _step5.value;
+          const filterByTk = values[_this8.model.primaryKeyAttribute];
+
+          if (!filterByTk) {
+            throw new Error('filterByTk invalid');
+          }
+
+          const instance = yield _this8.update({
+            values,
+            filterByTk,
+            transaction
+          });
+          instances.push(instance);
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+
+      return instances;
+    })();
+  }
+
+  destroy(options) {
+    var _this9 = this;
+
+    return _asyncToGenerator(function* () {
+      const transaction = yield _this9.getTransaction(options);
+      const modelFilterKey = _this9.collection.filterTargetKey;
       options = options;
 
       if (options['individualHooks'] === undefined) {
@@ -420,8 +536,16 @@ class Repository {
 
       const filterByTk = options.filterByTk && !_lodash().default.isArray(options.filterByTk) ? [options.filterByTk] : options.filterByTk;
 
+      if (_this9.collection.model.primaryKeyAttributes.length !== 1 && filterByTk && !_lodash().default.get(_this9.collection.options, 'filterTargetKey')) {
+        if (_this9.collection.model.primaryKeyAttributes.length > 1) {
+          throw new Error(`filterByTk is not supported for composite primary key`);
+        } else {
+          throw new Error(`filterByTk is not supported for collection that has no primary key`);
+        }
+      }
+
       if (filterByTk && !options.filter) {
-        return yield _this8.model.destroy(_objectSpread(_objectSpread({}, options), {}, {
+        return yield _this9.model.destroy(_objectSpread(_objectSpread({}, options), {}, {
           where: {
             [modelFilterKey]: {
               [_sequelize().Op.in]: filterByTk
@@ -432,7 +556,15 @@ class Repository {
       }
 
       if (options.filter) {
-        let pks = (yield _this8.find({
+        if (_this9.collection.model.primaryKeyAttributes.length !== 1 && !_lodash().default.get(_this9.collection.options, 'filterTargetKey')) {
+          const queryOptions = _objectSpread({}, _this9.buildQueryOptions(options));
+
+          return yield _this9.model.destroy(_objectSpread(_objectSpread({}, queryOptions), {}, {
+            transaction
+          }));
+        }
+
+        let pks = (yield _this9.find({
           filter: options.filter,
           transaction
         })).map(instance => instance.get(modelFilterKey));
@@ -441,14 +573,14 @@ class Repository {
           pks = _lodash().default.intersection(pks.map(i => `${i}`), filterByTk.map(i => `${i}`));
         }
 
-        return yield _this8.destroy(_objectSpread(_objectSpread({}, _lodash().default.omit(options, 'filter')), {}, {
+        return yield _this9.destroy(_objectSpread(_objectSpread({}, _lodash().default.omit(options, 'filter')), {}, {
           filterByTk: pks,
           transaction
         }));
       }
 
       if (options.truncate) {
-        return yield _this8.model.destroy(_objectSpread(_objectSpread({}, options), {}, {
+        return yield _this9.model.destroy(_objectSpread(_objectSpread({}, options), {}, {
           truncate: true,
           transaction
         }));
@@ -486,7 +618,7 @@ class Repository {
   }
 
   getTransaction(options, autoGen = false) {
-    var _this9 = this;
+    var _this10 = this;
 
     return _asyncToGenerator(function* () {
       if (_lodash().default.isPlainObject(options) && options.transaction) {
@@ -494,7 +626,7 @@ class Repository {
       }
 
       if (autoGen) {
-        return yield _this9.model.sequelize.transaction();
+        return yield _this10.model.sequelize.transaction();
       }
 
       return null;
@@ -511,6 +643,8 @@ __decorate([transaction()], Repository.prototype, "createMany", null);
 
 __decorate([transaction(), (0, _mustHaveFilterDecorator.default)()], Repository.prototype, "update", null);
 
+__decorate([transaction()], Repository.prototype, "updateMany", null);
+
 __decorate([transaction((args, transaction) => {
   return {
     filterByTk: args[0],

package/lib/sync-runner.d.ts

@@ -0,0 +1,4 @@
+export declare class SyncRunner {
+    static syncInheritModel(model: any, options: any): Promise<void>;
+    static createTable(tableName: any, attributes: any, options: any, model: any, parentTables: any): Promise<any>;
+}