@nocobase/database 0.5.0-alpha.38 → 0.7.0-alpha.0

package/lib/model.d.ts

@@ -1,49 +1,15 @@
-import { Model as SequelizeModel, ProjectionAlias, SaveOptions } from 'sequelize';
-import Database from './database';
-export interface ApiJsonOptions {
-    fields?: string[] | {
-        only?: string[];
-        appends?: string[];
-    } | {
-        except?: string[];
-        appends?: string[];
-    };
-    filter?: any;
-    sort?: any;
-    page?: number;
-    perPage?: number;
-    context?: any;
+import { Model as SequelizeModel } from 'sequelize';
+import { Collection } from './collection';
+import { Database } from './database';
+interface IModel {
     [key: string]: any;
 }
-export interface WithCountAttributeOptions {
-    association: string;
-    sourceAlias?: string;
-    where?: any;
-    alias?: string;
-    [key: string]: any;
-}
-export declare const DEFAULT_OFFSET = 0;
-export declare const DEFAULT_LIMIT = 100;
-export declare const MAX_LIMIT = 500;
-export interface UpdateAssociationOptions extends SaveOptions {
-    context?: any;
-}
-export declare abstract class Model extends SequelizeModel {
-    [key: string]: any;
+export declare class Model<TModelAttributes extends {} = any, TCreationAttributes extends {} = TModelAttributes> extends SequelizeModel<TModelAttributes, TCreationAttributes> implements IModel {
     static database: Database;
-    get database(): Database;
-    static withCountAttribute(options?: string | WithCountAttributeOptions): string | ProjectionAlias;
-    static selectQuery(options?: {}): string;
-    static parseApiJson(options: ApiJsonOptions): any;
-    getValuesByFieldNames(scope?: any[]): {};
-    updateSingleAssociation(key: string, data: any, options?: UpdateAssociationOptions): Promise<void>;
-    updateMultipleAssociation(associationName: string, data: any, options?: UpdateAssociationOptions): Promise<void>;
-    updateAssociation(key: string, data: any, options?: UpdateAssociationOptions): Promise<void>;
-    updateAssociations(data: any, options?: UpdateAssociationOptions): Promise<void>;
+    static collection: Collection;
+    toJSON<T extends TModelAttributes>(): T;
+    private hiddenObjKey;
+    private sortAssociations;
+    private sortArray;
 }
-export declare type ModelCtor<M extends Model> = typeof Model & {
-    new (): M;
-} & {
-    [key: string]: any;
-};
-export default Model;
+export {};

package/lib/model.js

@@ -1,463 +1,87 @@
 "use strict";
-
-function _react() {
-  const data = _interopRequireDefault(require("react"));
-
-  _react = function _react() {
-    return data;
-  };
-
-  return data;
-}
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-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; }
-
-var __awaiter = void 0 && (void 0).__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 __rest = void 0 && (void 0).__rest || function (s, e) {
-  var t = {};
-
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-
-  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-  }
-  return t;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Model = exports.MAX_LIMIT = exports.DEFAULT_LIMIT = exports.DEFAULT_OFFSET = void 0;
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
 const sequelize_1 = require("sequelize");
-
-const fields_1 = require("./fields");
-
-const utils_1 = require("./utils");
-
-exports.DEFAULT_OFFSET = 0;
-exports.DEFAULT_LIMIT = 100;
-exports.MAX_LIMIT = 500;
-
+const lodash_1 = __importDefault(require("lodash"));
 class Model extends sequelize_1.Model {
-  get database() {
-    return this.constructor.database;
-  }
-
-  static withCountAttribute(options) {
-    if (typeof options === 'string') {
-      options = {
-        association: options
-      };
-    }
-
-    const _options = options,
-          sourceAlias = _options.sourceAlias,
-          association = _options.association,
-          _options$where = _options.where,
-          where = _options$where === void 0 ? {} : _options$where,
-          alias = _options.alias,
-          restOptions = __rest(options, ["sourceAlias", "association", "where", "alias"]);
-
-    const associator = this.associations[association];
-    const table = this.database.getTable(this.name);
-    const field = table.getField(association);
-    const _field$options = field.options,
-          targetKey = _field$options.targetKey,
-          otherKey = _field$options.otherKey,
-          foreignKey = _field$options.foreignKey,
-          sourceKey = _field$options.sourceKey;
-
-    if (associator.associationType === 'HasMany') {
-      where[foreignKey] = {
-        [sequelize_1.Op.eq]: sequelize_1.Sequelize.col(`${sourceAlias || this.name}.${sourceKey}`)
-      };
-    } else if (associator.associationType === 'BelongsToMany') {
-      where[targetKey] = {
-        [sequelize_1.Op.in]: sequelize_1.Sequelize.literal(`(${associator.through.model.selectQuery({
-          attributes: [otherKey],
-          where: Object.assign({
-            [foreignKey]: {
-              [sequelize_1.Op.eq]: sequelize_1.Sequelize.col(`${sourceAlias || this.name}.${sourceKey}`)
+    toJSON() {
+        const handleObj = (obj, options) => {
+            const handles = [
+                (data) => {
+                    if (data instanceof Model) {
+                        return data.toJSON();
+                    }
+                    return data;
+                },
+                this.hiddenObjKey,
+            ];
+            return handles.reduce((carry, fn) => fn.apply(this, [carry, options]), obj);
+        };
+        const handleArray = (arrayOfObj, options) => {
+            const handles = [this.sortAssociations];
+            return handles.reduce((carry, fn) => fn.apply(this, [carry, options]), arrayOfObj || []);
+        };
+        const opts = {
+            model: this.constructor,
+            collection: this.constructor.collection,
+            db: this.constructor.database,
+        };
+        const traverseJSON = (data, options) => {
+            const { model, db, collection } = options;
+            // handle Object
+            data = handleObj(data, options);
+            const result = {};
+            for (const key of Object.keys(data)) {
+                // @ts-ignore
+                if (model.hasAlias(key)) {
+                    const association = model.associations[key];
+                    const opts = {
+                        model: association.target,
+                        collection: db.getCollection(association.target.name),
+                        db,
+                        key,
+                        field: collection.getField(key),
+                    };
+                    if (['HasMany', 'BelongsToMany'].includes(association.associationType)) {
+                        result[key] = handleArray(data[key], opts).map((item) => traverseJSON(item, opts));
+                    }
+                    else {
+                        result[key] = data[key] ? traverseJSON(data[key], opts) : null;
+                    }
+                }
+                else {
+                    result[key] = data[key];
+                }
             }
-          }, associator.through.scope || {})
-        })})`)
-      };
-    }
-
-    let countLiteral = 'count(*)';
-
-    if (this.database.sequelize.getDialect() === 'postgres') {
-      countLiteral = 'cast(count(*) as integer)';
+            return result;
+        };
+        return traverseJSON(super.toJSON(), opts);
     }
-
-    const attribute = [sequelize_1.Sequelize.literal(`(${associator.target.selectQuery(Object.assign(Object.assign({}, restOptions), {
-      attributes: [[sequelize_1.Sequelize.literal(countLiteral), 'count']],
-      where: Object.assign(Object.assign({}, where), associator.scope || {})
-    }))})`), alias || sequelize_1.Utils.underscoredIf(`${association}Count`, this.options.underscored)].filter(Boolean);
-    return attribute;
-  }
-
-  static selectQuery(options = {}) {
-    return this.queryGenerator.selectQuery(this.getTableName(), options, this).replace(/;$/, '');
-  }
-
-  static parseApiJson(options) {
-    const fields = options.fields,
-          filter = options.filter,
-          sort = options.sort,
-          context = options.context,
-          page = options.page,
-          perPage = options.perPage;
-    const data = (0, utils_1.toInclude)({
-      fields,
-      filter,
-      sort
-    }, {
-      model: this,
-      associations: this.associations,
-      dialect: this.sequelize.getDialect(),
-      ctx: context,
-      database: this.database
-    });
-
-    if (page || perPage) {
-      data.limit = perPage === -1 ? exports.MAX_LIMIT : Math.min(perPage || exports.DEFAULT_LIMIT, exports.MAX_LIMIT);
-      data.offset = data.limit * (page > 0 ? page - 1 : exports.DEFAULT_OFFSET);
+    hiddenObjKey(obj, options) {
+        const hiddenFields = Array.from(options.collection.fields.values())
+            .filter((field) => field.options.hidden)
+            .map((field) => field.options.name);
+        return lodash_1.default.omit(obj, hiddenFields);
     }
-
-    if (data.attributes && data.attributes.length === 0) {
-      delete data.attributes;
+    sortAssociations(data, { field }) {
+        const sortBy = field.options.sortBy;
+        return sortBy ? this.sortArray(data, sortBy) : data;
     }
-
-    return data;
-  }
-
-  getValuesByFieldNames(scope = []) {
-    const table = this.database.getTable(this.constructor.name);
-    const Model = table.getModel();
-    const associations = table.getAssociations();
-    const where = {};
-    scope.forEach(col => {
-      const association = associations.get(col);
-      const dataKey = association && association instanceof fields_1.BELONGSTO ? association.options.foreignKey : col;
-
-      if (!Model.rawAttributes[dataKey]) {
-        return;
-      }
-
-      const value = this.getDataValue(dataKey);
-
-      if (typeof value !== 'undefined') {
-        where[dataKey] = value;
-      }
-    });
-    return where;
-  }
-
-  updateSingleAssociation(key, data, options = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const fields = options.fields,
-            _options$transaction = options.transaction,
-            transaction = _options$transaction === void 0 ? yield this.sequelize.transaction() : _options$transaction,
-            opts = __rest(options, ["fields", "transaction"]);
-
-      Object.assign(opts, {
-        transaction
-      });
-      const table = this.database.getTable(this.constructor.name);
-      const association = table.getAssociations().get(key);
-      const accessors = association.getAccessors();
-
-      if (data == null) {
-        yield this[accessors.set](null, opts);
-        return;
-      }
-
-      if (typeof data === 'number' || typeof data === 'string' || data instanceof sequelize_1.Model) {
-        yield this[accessors.set](data, opts);
-      } else if (typeof data === 'object') {
-        const Target = association.getTargetModel();
-        const targetAttribute = association instanceof fields_1.BELONGSTO ? association.options.targetKey : association.options.sourceKey;
-
-        if (data[targetAttribute]) {
-          if (Object.keys(data).length > 0) {
-            const target = yield Target.findOne({
-              where: {
-                [targetAttribute]: data[targetAttribute]
-              },
-              transaction
-            });
-
-            if (target) {
-              yield this[accessors.set](data[targetAttribute], opts);
-              yield target.update(data, opts);
-              yield target.updateAssociations(data, opts);
-            } else {
-              const t = yield this[accessors.create](data, opts);
-              yield t.updateAssociations(data, opts);
-            }
-          }
-        } else {
-          const t = yield this[accessors.create](data, opts);
-          yield t.updateAssociations(data, opts);
-        }
-      }
-
-      if (!options.transaction) {
-        yield transaction.commit();
-      }
-    });
-  }
-
-  updateMultipleAssociation(associationName, data, options = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const items = Array.isArray(data) ? data : data == null ? [] : [data];
-
-      const fields = options.fields,
-            _options$transaction2 = options.transaction,
-            transaction = _options$transaction2 === void 0 ? yield this.sequelize.transaction() : _options$transaction2,
-            opts = __rest(options, ["fields", "transaction"]);
-
-      Object.assign(opts, {
-        transaction
-      });
-      const table = this.database.getTable(this.constructor.name);
-      const association = table.getAssociations().get(associationName);
-      const accessors = association.getAccessors();
-
-      if (!items.length) {
-        yield this[accessors.set](null, opts);
-        return;
-      }
-
-      const Target = association.getTargetModel();
-      const _association$options$ = association.options.targetKey,
-            targetKey = _association$options$ === void 0 ? Target.primaryKeyAttribute : _association$options$;
-      const targetPk = Target.primaryKeyAttribute;
-      const targetKeyIsPk = targetKey === targetPk;
-      const toSetPks = new Set();
-      const toSetUks = new Set();
-      const toSetItems = new Set();
-      const toUpsertObjects = [];
-      items.forEach(item => {
-        if (item instanceof sequelize_1.Model) {
-          if (targetKeyIsPk) {
-            toSetPks.add(item.getDataValue(targetPk));
-          } else {
-            toSetUks.add(item.getDataValue(targetKey));
-          }
-
-          return;
+    sortArray(data, sortBy) {
+        if (!lodash_1.default.isArray(sortBy)) {
+            sortBy = [sortBy];
         }
-
-        if (typeof item === 'number' || typeof item === 'string') {
-          let targetKeyType = (0, fields_1.getDataTypeKey)(Target.rawAttributes[targetKey].type).toLocaleLowerCase();
-
-          if (targetKeyType === 'integer') {
-            targetKeyType = 'number';
-          }
-
-          if (typeof item !== targetKeyType) {
-            throw new Error(`target key type [${typeof item}] does not match to [${targetKeyType}]`);
-          }
-
-          if (targetKeyIsPk) {
-            toSetPks.add(item);
-          } else {
-            toSetUks.add(item);
-          }
-
-          return;
-        }
-
-        if (typeof item === 'object') {
-          toUpsertObjects.push(item);
-        }
-      });
-      const byPkExistItems = toSetPks.size ? yield Target.findAll(Object.assign(Object.assign({}, opts), {
-        where: {
-          [targetPk]: {
-            [sequelize_1.Op.in]: Array.from(toSetPks)
-          }
-        },
-        attributes: [targetPk]
-      })) : [];
-      byPkExistItems.forEach(item => {
-        toSetItems.add(item);
-      });
-      const byUkExistItems = toSetUks.size ? yield Target.findAll(Object.assign(Object.assign({}, opts), {
-        where: {
-          [targetKey]: {
-            [sequelize_1.Op.in]: Array.from(toSetUks)
-          }
-        },
-        attributes: [targetPk, targetKey]
-      })) : [];
-      byUkExistItems.forEach(item => {
-        toSetItems.add(item);
-      });
-      const belongsToManyList = [];
-
-      for (var _i = 0, _toUpsertObjects = toUpsertObjects; _i < _toUpsertObjects.length; _i++) {
-        const item = _toUpsertObjects[_i];
-        let target;
-
-        if (typeof item[targetKey] === 'undefined') {
-          target = yield this[accessors.create](item, opts);
-        } else {
-          target = yield Target.findOne(Object.assign(Object.assign({}, opts), {
-            where: {
-              [targetKey]: item[targetKey]
-            }
-          }));
-
-          if (!target) {
-            target = yield this[accessors.create](item, opts);
-          } else {
-            yield target.update(item, opts);
-          }
-        }
-
-        toSetItems.add(target);
-
-        if (association instanceof fields_1.BELONGSTOMANY) {
-          belongsToManyList.push({
-            item,
-            target
-          });
-        }
-
-        yield target.updateAssociations(item, opts);
-      }
-
-      yield this[accessors.set](Array.from(toSetItems), opts);
-
-      if (belongsToManyList.length) {
-        const ThroughModel = association.getThroughModel();
-        const throughName = association.getThroughName();
-
-        var _iterator = _createForOfIteratorHelper(belongsToManyList),
-            _step;
-
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            const _step$value = _step.value,
-                  item = _step$value.item,
-                  target = _step$value.target;
-            const throughValues = item[throughName];
-
-            if (throughValues && typeof throughValues === 'object') {
-              const _association$options = association.options,
-                    foreignKey = _association$options.foreignKey,
-                    sourceKey = _association$options.sourceKey,
-                    otherKey = _association$options.otherKey;
-              const through = yield ThroughModel.findOne({
-                where: {
-                  [foreignKey]: this.get(sourceKey),
-                  [otherKey]: target.get(targetKey)
-                },
-                transaction
-              });
-              yield through.update(throughValues, opts);
-            }
-          }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
-        }
-      }
-
-      if (!options.transaction) {
-        yield transaction.commit();
-      }
-    });
-  }
-
-  updateAssociation(key, data, options = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const table = this.database.getTable(this.constructor.name);
-      const association = table.getAssociations().get(key);
-
-      switch (true) {
-        case association instanceof fields_1.BELONGSTO:
-        case association instanceof fields_1.HASONE:
-          return this.updateSingleAssociation(key, data, options);
-
-        case association instanceof fields_1.HASMANY:
-        case association instanceof fields_1.BELONGSTOMANY:
-          return this.updateMultipleAssociation(key, data, options);
-      }
-    });
-  }
-
-  updateAssociations(data, options = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const _options$transaction3 = options.transaction,
-            transaction = _options$transaction3 === void 0 ? yield this.sequelize.transaction() : _options$transaction3;
-
-      for (var _i2 = 0, _Object$keys = Object.keys(this.constructor.associations); _i2 < _Object$keys.length; _i2++) {
-        const key = _Object$keys[_i2];
-
-        if (!Object.keys(data).includes(key)) {
-          continue;
-        }
-
-        yield this.updateAssociation(key, data[key], Object.assign(Object.assign({}, options), {
-          transaction
-        }));
-      }
-
-      yield this.database.emitAsync('afterUpdateAssociations', this, Object.assign(Object.assign({}, options), {
-        transaction
-      }));
-
-      if (!options.transaction) {
-        yield transaction.commit();
-      }
-    });
-  }
-
+        const orderItems = [];
+        const orderDirections = [];
+        sortBy.forEach((sortItem) => {
+            orderDirections.push(sortItem.startsWith('-') ? 'desc' : 'asc');
+            orderItems.push(sortItem.replace('-', ''));
+        });
+        return lodash_1.default.orderBy(data, orderItems, orderDirections);
+    }
 }
-
 exports.Model = Model;
-exports.default = Model;
-//# sourceMappingURL=model.js.map
+//# sourceMappingURL=model.js.map