@nocobase/database 0.9.4-alpha.2 → 0.10.0-alpha.2

package/lib/database.js

@@ -593,7 +593,8 @@ class Database extends _events().EventEmitter {
     if (!Field) {
       throw Error(`unsupported field type ${type}`);
     }
-    if (options.field && context.collection.options.underscored) {
+    const collection = context.collection;
+    if (options.field && collection.options.underscored && !collection.isView()) {
       options.field = (0, _utils2.snakeCase)(options.field);
     }
     return new Field(options, context);

package/lib/eager-loading/eager-loading-tree.d.ts

@@ -1,4 +1,5 @@
 import { Association, Includeable, Model, ModelStatic, Transaction } from 'sequelize';
+import Database from '../database';
 interface EagerLoadingNode {
     model: ModelStatic<any>;
     association: Association;
@@ -8,15 +9,18 @@ interface EagerLoadingNode {
     parent?: EagerLoadingNode;
     instances?: Array<Model>;
     order?: any;
+    inspectInheritAttribute?: boolean;
 }
 export declare class EagerLoadingTree {
     root: EagerLoadingNode;
+    db: Database;
     constructor(root: EagerLoadingNode);
     static buildFromSequelizeOptions(options: {
         model: ModelStatic<any>;
         rootAttributes: Array<string>;
         rootOrder?: any;
         includeOption: Includeable | Includeable[];
+        db: Database;
     }): EagerLoadingTree;
     load(pks: Array<string | number>, transaction?: Transaction): Promise<{}>;
 }

package/lib/eager-loading/eager-loading-tree.js

@@ -4,6 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.EagerLoadingTree = void 0;
+function _sequelize() {
+  const data = require("sequelize");
+  _sequelize = function _sequelize() {
+    return data;
+  };
+  return data;
+}
 function _lodash() {
   const data = _interopRequireDefault(require("lodash"));
   _lodash = function _lodash() {
@@ -11,6 +18,8 @@ function _lodash() {
   };
   return data;
 }
+var _optionsParser = require("../options-parser");
+var _appendChildCollectionNameAfterRepositoryFind = require("../listeners/append-child-collection-name-after-repository-find");
 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; }
@@ -22,28 +31,49 @@ function _asyncToGenerator(fn) { return function () { var self = this, args = ar
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+const pushAttribute = (node, attribute) => {
+  if (_lodash().default.isArray(node.attributes) && !node.attributes.includes(attribute)) {
+    node.attributes.push(attribute);
+  }
+};
+const EagerLoadingNodeProto = {
+  afterBuild(db) {
+    const collection = db.modelCollection.get(this.model);
+    if (collection && collection.isParent()) {
+      if (!this.attributes) {
+        this.attributes = {
+          include: []
+        };
+      }
+      _optionsParser.OptionsParser.appendInheritInspectAttribute(_lodash().default.isArray(this.attributes) ? this.attributes : this.attributes.include, collection);
+      this.inspectInheritAttribute = true;
+    }
+  }
+};
 class EagerLoadingTree {
   constructor(root) {
     this.root = void 0;
+    this.db = void 0;
     this.root = root;
   }
   static buildFromSequelizeOptions(options) {
     const model = options.model,
       rootAttributes = options.rootAttributes,
-      includeOption = options.includeOption;
-    const root = {
+      includeOption = options.includeOption,
+      db = options.db;
+    const buildNode = node => {
+      Object.setPrototypeOf(node, EagerLoadingNodeProto);
+      node.afterBuild(db);
+      return node;
+    };
+    const root = buildNode({
       model,
       association: null,
       rawAttributes: _lodash().default.cloneDeep(rootAttributes),
       attributes: _lodash().default.cloneDeep(rootAttributes),
       order: options.rootOrder,
       children: []
-    };
-    const pushAttribute = (node, attribute) => {
-      if (_lodash().default.isArray(node.attributes) && !node.attributes.includes(attribute)) {
-        node.attributes.push(attribute);
-      }
-    };
+    });
     const traverseIncludeOption = (includeOption, eagerLoadingTreeParent) => {
       const includeOptions = _lodash().default.castArray(includeOption);
       if (includeOption.length > 0) {
@@ -61,14 +91,14 @@ class EagerLoadingTree {
           }
           const association = eagerLoadingTreeParent.model.associations[include.association];
           const associationType = association.associationType;
-          const child = {
+          const child = buildNode({
             model: association.target,
             association,
             rawAttributes: _lodash().default.cloneDeep(include.attributes),
             attributes: _lodash().default.cloneDeep(include.attributes),
             parent: eagerLoadingTreeParent,
             children: []
-          };
+          });
           if (associationType == 'HasOne' || associationType == 'HasMany') {
             const sourceKey = association.sourceKey,
               foreignKey = association.foreignKey;
@@ -97,12 +127,22 @@ class EagerLoadingTree {
       }
     };
     traverseIncludeOption(includeOption, root);
-    return new EagerLoadingTree(root);
+    const tree = new EagerLoadingTree(root);
+    tree.db = db;
+    return tree;
   }
   load(pks, transaction) {
     var _this = this;
     return _asyncToGenerator(function* () {
       const result = {};
+      const orderOption = association => {
+        const targetModel = association.target;
+        const order = [];
+        if (targetModel.primaryKeyAttribute && targetModel.rawAttributes[targetModel.primaryKeyAttribute].autoIncrement) {
+          order.push([targetModel.primaryKeyAttribute, 'ASC']);
+        }
+        return order;
+      };
       const loadRecursive = /*#__PURE__*/function () {
         var _ref = _asyncToGenerator(function* (node, ids) {
           const modelPrimaryKey = node.model.primaryKeyAttribute;
@@ -132,6 +172,7 @@ class EagerLoadingTree {
                   [foreignKey]: foreignKeyValues
                 },
                 attributes: node.attributes,
+                order: orderOption(association),
                 transaction
               };
               instances = yield node.model.findAll(findOptions);
@@ -149,15 +190,21 @@ class EagerLoadingTree {
             }
             if (associationType == 'BelongsToMany') {
               const foreignKeyValues = node.parent.instances.map(instance => instance.get(association.sourceKey));
+              const pivotAssoc = new (_sequelize().HasOne)(association.target, association.through.model, {
+                as: '_pivot_',
+                foreignKey: association.otherKey,
+                sourceKey: association.targetKey
+              });
               instances = yield node.model.findAll({
                 transaction,
                 attributes: node.attributes,
                 include: [{
-                  association: association.oneFromTarget,
+                  association: pivotAssoc,
                   where: {
                     [association.foreignKey]: foreignKeyValues
                   }
-                }]
+                }],
+                order: orderOption(association)
               });
             }
           }
@@ -252,13 +299,17 @@ class EagerLoadingTree {
             if (associationType == 'BelongsToMany') {
               const sourceKey = association.sourceKey;
               const foreignKey = association.foreignKey;
-              const oneFromTarget = association.oneFromTarget;
+              const as = association.oneFromTarget.as;
               var _iterator6 = _createForOfIteratorHelper(node.instances),
                 _step6;
               try {
                 for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
                   const instance = _step6.value;
-                  const parentInstance = node.parent.instances.find(parentInstance => parentInstance.get(sourceKey) == instance[oneFromTarget.as].get(foreignKey));
+                  // set instance accessor
+                  instance[as] = instance.dataValues[as] = instance['_pivot_'];
+                  delete instance.dataValues['_pivot_'];
+                  delete instance['_pivot_'];
+                  const parentInstance = node.parent.instances.find(parentInstance => parentInstance.get(sourceKey) == instance.dataValues[as].get(foreignKey));
                   if (parentInstance) {
                     const children = parentInstance.getDataValue(association.as);
                     if (!children) {
@@ -293,13 +344,25 @@ class EagerLoadingTree {
         };
       }();
       yield loadRecursive(_this.root, pks);
+      const appendChildCollectionName = (0, _appendChildCollectionNameAfterRepositoryFind.appendChildCollectionNameAfterRepositoryFind)(_this.db);
       const setInstanceAttributes = node => {
-        const nodeRawAttributes = node.rawAttributes;
+        if (node.inspectInheritAttribute) {
+          appendChildCollectionName({
+            findOptions: {},
+            data: node.instances,
+            dataCollection: _this.db.modelCollection.get(node.model)
+          });
+        }
+        // if no attributes are specified, return empty fields
+        const nodeRawAttributes = node.rawAttributes || [];
         if (!_lodash().default.isArray(nodeRawAttributes)) {
           return;
         }
         const nodeChildrenAs = node.children.map(child => child.association.as);
         const includeAttributes = [...nodeRawAttributes, ...nodeChildrenAs];
+        if (node.inspectInheritAttribute) {
+          includeAttributes.push('__schemaName', '__tableName', '__collection');
+        }
         var _iterator8 = _createForOfIteratorHelper(node.instances),
           _step8;
         try {

package/lib/fields/belongs-to-field.d.ts

@@ -2,8 +2,8 @@ import { BelongsToOptions as SequelizeBelongsToOptions } from 'sequelize';
 import { Reference } from '../features/ReferencesMap';
 import { BaseRelationFieldOptions, RelationField } from './relation-field';
 export declare class BelongsToField extends RelationField {
-    get dataType(): string;
     static type: string;
+    get dataType(): string;
     get target(): any;
     static toReference(db: any, association: any, onDelete: any): {
         sourceCollectionName: any;

package/lib/fields/belongs-to-field.js

@@ -85,7 +85,8 @@ class BelongsToField extends _relationField.RelationField {
       this.options.sourceKey = association.sourceKey;
     }
     this.collection.addIndex([this.options.foreignKey]);
-    this.database.referenceMap.addReference(this.reference(association));
+    const reference = this.reference(association);
+    this.database.referenceMap.addReference(reference);
     return true;
   }
   unbind() {
@@ -105,7 +106,7 @@ class BelongsToField extends _relationField.RelationField {
       collection.model.removeAttribute(foreignKey);
     }
     const association = collection.model.associations[this.name];
-    if (association) {
+    if (association && !this.options.inherit) {
       const reference = this.reference(association);
       this.database.referenceMap.removeReference(reference);
     }

package/lib/fields/belongs-to-many-field.js

@@ -119,7 +119,7 @@ class BelongsToManyField extends _relationField.RelationField {
     database.removePendingField(this);
     // 删掉 model 的关联字段
     const association = collection.model.associations[this.name];
-    if (association) {
+    if (association && !this.options.inherit) {
       this.references(association).forEach(reference => this.database.referenceMap.removeReference(reference));
     }
     this.clearAccessors();

package/lib/fields/has-many-field.js

@@ -114,7 +114,7 @@ class HasManyField extends _relationField.RelationField {
       }
     }
     const association = collection.model.associations[this.name];
-    if (association) {
+    if (association && !this.options.inherit) {
       this.database.referenceMap.removeReference(this.reference(association));
     }
     this.clearAccessors();

package/lib/fields/has-one-field.js

@@ -118,7 +118,7 @@ class HasOneField extends _relationField.RelationField {
       }
     }
     const association = collection.model.associations[this.name];
-    if (association) {
+    if (association && !this.options.inherit) {
       this.database.referenceMap.removeReference(this.reference(association));
     }
     this.clearAccessors();

package/lib/listeners/append-child-collection-name-after-repository-find.js

@@ -19,7 +19,11 @@ const appendChildCollectionNameAfterRepositoryFind = db => {
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
           const row = _step.value;
-          const rowCollection = db.tableNameCollectionMap.get(findOptions.raw ? `${row['__schemaName']}.${row['__tableName']}` : `${row.get('__schemaName')}.${row.get('__tableName')}`);
+          if (row.__collection) {
+            continue;
+          }
+          const fullTableName = findOptions.raw ? `${row['__schemaName']}.${row['__tableName']}` : `${row.get('__schemaName')}.${row.get('__tableName')}`;
+          const rowCollection = db.tableNameCollectionMap.get(fullTableName);
           if (!rowCollection) {
             db.logger.warn(`Can not find collection by table name ${JSON.stringify(row)}, current collections: ${Array.from(db.tableNameCollectionMap.keys()).join(', ')}`);
             return;

package/lib/options-parser.d.ts

@@ -15,6 +15,7 @@ export declare class OptionsParser {
     filterParser: FilterParser;
     context: OptionsParserContext;
     constructor(options: FindOptions, context: OptionsParserContext);
+    static appendInheritInspectAttribute(include: any, collection: any): any;
     isAssociation(key: string): boolean;
     isAssociationPath(path: string): boolean;
     toSequelizeParams(): any;
@@ -24,7 +25,6 @@ export declare class OptionsParser {
      * @protected
      */
     protected parseSort(filterParams: any): any;
-    protected inheritFromSubQuery(include: any): any;
     protected parseFields(filterParams: any): any;
     protected parseExcept(except: Except, filterParams: any): any;
     protected parseAppends(appends: Appends, filterParams: any): any;

package/lib/options-parser.js

@@ -43,6 +43,19 @@ class OptionsParser {
     });
     this.context = context;
   }
+  static appendInheritInspectAttribute(include, collection) {
+    // if include already has __tableName, __schemaName, skip
+    if (include.find(item => (item === null || item === void 0 ? void 0 : item[1]) === '__tableName')) {
+      return;
+    }
+    include.push([_sequelize().Sequelize.literal(`(select relname from pg_class where pg_class.oid = "${collection.name}".tableoid)`), '__tableName']);
+    include.push([_sequelize().Sequelize.literal(`
+        (SELECT n.nspname
+        FROM pg_class c
+               JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.oid = "${collection.name}".tableoid)
+      `), '__schemaName']);
+  }
   isAssociation(key) {
     return this.model.associations[key] !== undefined;
   }
@@ -113,15 +126,6 @@ class OptionsParser {
     }
     return filterParams;
   }
-  inheritFromSubQuery(include) {
-    include.push([_sequelize().Sequelize.literal(`(select relname from pg_class where pg_class.oid = "${this.collection.name}".tableoid)`), '__tableName']);
-    include.push([_sequelize().Sequelize.literal(`
-        (SELECT n.nspname
-        FROM pg_class c
-               JOIN pg_namespace n ON n.oid = c.relnamespace
-        WHERE c.oid = "${this.collection.name}".tableoid)
-      `), '__schemaName']);
-  }
   parseFields(filterParams) {
     var _this$options3, _this$options4, _this$options5, _this$options6;
     const appends = ((_this$options3 = this.options) === null || _this$options3 === void 0 ? void 0 : _this$options3.appends) || [];
@@ -136,12 +140,12 @@ class OptionsParser {
       exclude: []
     }; // out put all fields by default
     if (this.collection.isParent()) {
-      this.inheritFromSubQuery(attributes.include);
+      OptionsParser.appendInheritInspectAttribute(attributes.include, this.collection);
     }
     if ((_this$options5 = this.options) === null || _this$options5 === void 0 ? void 0 : _this$options5.fields) {
       attributes = [];
       if (this.collection.isParent()) {
-        this.inheritFromSubQuery(attributes);
+        OptionsParser.appendInheritInspectAttribute(attributes, this.collection);
       }
       // 将fields拆分为 attributes 和 appends
       var _iterator2 = _createForOfIteratorHelper(this.options.fields),

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

@@ -65,7 +65,8 @@ class MultipleRelationRepository extends _relationRepository.RelationRepository
           model: _this.targetModel,
           rootAttributes: findOptions.attributes,
           includeOption: findOptions.include,
-          rootOrder: findOptions.order
+          rootOrder: findOptions.order,
+          db: _this.db
         });
         yield eagerLoadingTree.load(ids.map(i => i.pk), transaction);
         return eagerLoadingTree.root.instances;

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

@@ -71,7 +71,8 @@ class SingleRelationRepository extends _relationRepository.RelationRepository {
         const eagerLoadingTree = _eagerLoadingTree.EagerLoadingTree.buildFromSequelizeOptions({
           model: _this3.targetModel,
           rootAttributes: findOptions.attributes,
-          includeOption: findOptions.include
+          includeOption: findOptions.include,
+          db: _this3.db
         });
         yield eagerLoadingTree.load([templateModel.get(_this3.targetModel.primaryKeyAttribute)], transaction);
         return eagerLoadingTree.root.instances[0];

package/lib/repository.d.ts

@@ -119,11 +119,18 @@ export interface AggregateOptions {
     filter?: Filter;
     distinct?: boolean;
 }
+interface FirstOrCreateOptions extends Transactionable {
+    filterKeys: string[];
+    values?: Values;
+}
 export declare class Repository<TModelAttributes extends {} = any, TCreationAttributes extends {} = TModelAttributes> implements IRepository {
     database: Database;
     collection: Collection;
     model: ModelStatic<Model>;
     constructor(collection: Collection);
+    static valuesToFilter(values: Values, filterKeys: Array<string>): {
+        $and: any[];
+    };
     /**
      * return count by filter
      */
@@ -152,6 +159,11 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
      * @param options
      */
     findOne(options?: FindOneOptions): Promise<any>;
+    /**
+     * Get the first record matching the attributes or create it.
+     */
+    firstOrCreate(options: FirstOrCreateOptions): Promise<any>;
+    updateOrCreate(options: FirstOrCreateOptions): Promise<any>;
     /**
      * Save instance to database
      *