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

package/lib/fields/array-field.js

@@ -1,30 +1,50 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.ArrayField = void 0;
-const field_1 = require("./field");
-const sequelize_1 = require("sequelize");
-class ArrayField extends field_1.Field {
-    get dataType() {
-        if (this.database.sequelize.getDialect() === 'postgres') {
-            return sequelize_1.DataTypes.JSONB;
-        }
-        return sequelize_1.DataTypes.JSON;
-    }
-    sortValue(model) {
-        const oldValue = model.get(this.options.name);
-        if (oldValue) {
-            const newValue = oldValue.sort();
-            model.set(this.options.name, newValue);
-        }
-    }
-    bind() {
-        super.bind();
-        this.on('beforeSave', this.sortValue.bind(this));
+
+var _field = require("./field");
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+class ArrayField extends _field.Field {
+  get dataType() {
+    if (this.database.sequelize.getDialect() === 'postgres') {
+      return _sequelize().DataTypes.JSONB;
     }
-    unbind() {
-        super.unbind();
-        this.off('beforeSave', this.sortValue.bind(this));
+
+    return _sequelize().DataTypes.JSON;
+  }
+
+  sortValue(model) {
+    const oldValue = model.get(this.options.name);
+
+    if (oldValue) {
+      const newValue = oldValue.sort();
+      model.set(this.options.name, newValue);
     }
+  }
+
+  bind() {
+    super.bind();
+    this.on('beforeSave', this.sortValue.bind(this));
+  }
+
+  unbind() {
+    super.unbind();
+    this.off('beforeSave', this.sortValue.bind(this));
+  }
+
 }
-exports.ArrayField = ArrayField;
-//# sourceMappingURL=array-field.js.map
+
+exports.ArrayField = ArrayField;

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

@@ -1,61 +1,108 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.BelongsToField = void 0;
-const lodash_1 = require("lodash");
-const sequelize_1 = require("sequelize");
-const relation_field_1 = require("./relation-field");
-class BelongsToField extends relation_field_1.RelationField {
-    get target() {
-        const { target, name } = this.options;
-        return target || sequelize_1.Utils.pluralize(name);
+
+function _lodash() {
+  const data = require("lodash");
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+var _relationField = require("./relation-field");
+
+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; }
+
+class BelongsToField extends _relationField.RelationField {
+  get target() {
+    const _this$options = this.options,
+          target = _this$options.target,
+          name = _this$options.name;
+    return target || _sequelize().Utils.pluralize(name);
+  }
+
+  bind() {
+    const _this$context = this.context,
+          database = _this$context.database,
+          collection = _this$context.collection;
+    const Target = this.TargetModel; // if target model not exists, add it to pending field,
+    // it will bind later
+
+    if (!Target) {
+      database.addPendingField(this);
+      return false;
     }
-    bind() {
-        const { database, collection } = this.context;
-        const Target = this.TargetModel;
-        // if target model not exists, add it to pending field,
-        // it will bind later
-        if (!Target) {
-            database.addPendingField(this);
-            return false;
-        }
-        if (collection.model.associations[this.name]) {
-            delete collection.model.associations[this.name];
-        }
-        // define relation on sequelize model
-        const association = collection.model.belongsTo(Target, Object.assign({ as: this.name }, (0, lodash_1.omit)(this.options, ['name', 'type', 'target'])));
-        // inverse relation
-        // this.TargetModel.hasMany(collection.model);
-        // 建立关系之后从 pending 列表中删除
-        database.removePendingField(this);
-        if (!this.options.foreignKey) {
-            this.options.foreignKey = association.foreignKey;
-        }
-        if (!this.options.sourceKey) {
-            // @ts-ignore
-            this.options.sourceKey = association.sourceKey;
-        }
-        return true;
+
+    if (collection.model.associations[this.name]) {
+      delete collection.model.associations[this.name];
+    } // define relation on sequelize model
+
+
+    const association = collection.model.belongsTo(Target, _objectSpread({
+      as: this.name
+    }, (0, _lodash().omit)(this.options, ['name', 'type', 'target']))); // inverse relation
+    // this.TargetModel.hasMany(collection.model);
+    // 建立关系之后从 pending 列表中删除
+
+    database.removePendingField(this);
+
+    if (!this.options.foreignKey) {
+      this.options.foreignKey = association.foreignKey;
     }
-    unbind() {
-        const { database, collection } = this.context;
-        // 如果关系字段还没建立就删除了，也同步删除待建立关联的关系字段
-        database.removePendingField(this);
-        // 如果外键没有显式的创建，关系表也无反向关联字段，删除关系时，外键也删除掉
-        const tcoll = database.collections.get(this.target);
-        const foreignKey = this.options.foreignKey;
-        const field1 = collection.getField(foreignKey);
-        const field2 = tcoll.findField((field) => {
-            return field.type === 'hasMany' && field.foreignKey === foreignKey;
-        });
-        if (!field1 && !field2) {
-            collection.model.removeAttribute(foreignKey);
-        }
-        // 删掉 model 的关联字段
-        delete collection.model.associations[this.name];
-        // @ts-ignore
-        collection.model.refreshAttributes();
+
+    if (!this.options.sourceKey) {
+      // @ts-ignore
+      this.options.sourceKey = association.sourceKey;
     }
+
+    return true;
+  }
+
+  unbind() {
+    const _this$context2 = this.context,
+          database = _this$context2.database,
+          collection = _this$context2.collection; // 如果关系字段还没建立就删除了，也同步删除待建立关联的关系字段
+
+    database.removePendingField(this); // 如果外键没有显式的创建，关系表也无反向关联字段，删除关系时，外键也删除掉
+
+    const tcoll = database.collections.get(this.target);
+    const foreignKey = this.options.foreignKey;
+    const field1 = collection.getField(foreignKey);
+    const field2 = tcoll.findField(field => {
+      return field.type === 'hasMany' && field.foreignKey === foreignKey;
+    });
+
+    if (!field1 && !field2) {
+      collection.model.removeAttribute(foreignKey);
+    } // 删掉 model 的关联字段
+
+
+    delete collection.model.associations[this.name]; // @ts-ignore
+
+    collection.model.refreshAttributes();
+  }
+
 }
+
 exports.BelongsToField = BelongsToField;
-BelongsToField.type = 'belongsTo';
-//# sourceMappingURL=belongs-to-field.js.map
+BelongsToField.type = 'belongsTo';

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

@@ -1,59 +1,104 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.BelongsToManyField = void 0;
-const lodash_1 = require("lodash");
-const sequelize_1 = require("sequelize");
-const relation_field_1 = require("./relation-field");
-class BelongsToManyField extends relation_field_1.RelationField {
-    get through() {
-        return (this.options.through ||
-            sequelize_1.Utils.camelize([this.context.collection.model.name, this.target]
-                .map((name) => name.toLowerCase())
-                .sort()
-                .join('_')));
+
+function _lodash() {
+  const data = require("lodash");
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+var _relationField = require("./relation-field");
+
+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; }
+
+class BelongsToManyField extends _relationField.RelationField {
+  get through() {
+    return this.options.through || _sequelize().Utils.camelize([this.context.collection.model.name, this.target].map(name => name.toLowerCase()).sort().join('_'));
+  }
+
+  bind() {
+    const _this$context = this.context,
+          database = _this$context.database,
+          collection = _this$context.collection;
+    const Target = this.TargetModel;
+
+    if (!Target) {
+      database.addPendingField(this);
+      return false;
+    }
+
+    const through = this.through;
+    let Through;
+
+    if (database.hasCollection(through)) {
+      Through = database.getCollection(through);
+    } else {
+      Through = database.collection({
+        name: through
+      });
+      Object.defineProperty(Through.model, 'isThrough', {
+        value: true
+      });
+    }
+
+    const association = collection.model.belongsToMany(Target, _objectSpread(_objectSpread({}, (0, _lodash().omit)(this.options, ['name', 'type', 'target'])), {}, {
+      as: this.name,
+      through: Through.model
+    })); // 建立关系之后从 pending 列表中删除
+
+    database.removePendingField(this);
+
+    if (!this.options.foreignKey) {
+      this.options.foreignKey = association.foreignKey;
+    }
+
+    if (!this.options.sourceKey) {
+      this.options.sourceKey = association.sourceKey;
     }
-    bind() {
-        const { database, collection } = this.context;
-        const Target = this.TargetModel;
-        if (!Target) {
-            database.addPendingField(this);
-            return false;
-        }
-        const through = this.through;
-        let Through;
-        if (database.hasCollection(through)) {
-            Through = database.getCollection(through);
-        }
-        else {
-            Through = database.collection({
-                name: through,
-            });
-            Object.defineProperty(Through.model, 'isThrough', { value: true });
-        }
-        const association = collection.model.belongsToMany(Target, Object.assign(Object.assign({}, (0, lodash_1.omit)(this.options, ['name', 'type', 'target'])), { as: this.name, through: Through.model }));
-        // 建立关系之后从 pending 列表中删除
-        database.removePendingField(this);
-        if (!this.options.foreignKey) {
-            this.options.foreignKey = association.foreignKey;
-        }
-        if (!this.options.sourceKey) {
-            this.options.sourceKey = association.sourceKey;
-        }
-        if (!this.options.otherKey) {
-            this.options.otherKey = association.otherKey;
-        }
-        if (!this.options.through) {
-            this.options.through = this.through;
-        }
-        return true;
+
+    if (!this.options.otherKey) {
+      this.options.otherKey = association.otherKey;
     }
-    unbind() {
-        const { database, collection } = this.context;
-        // 如果关系字段还没建立就删除了，也同步删除待建立关联的关系字段
-        database.removePendingField(this);
-        // 删掉 model 的关联字段
-        delete collection.model.associations[this.name];
+
+    if (!this.options.through) {
+      this.options.through = this.through;
     }
+
+    return true;
+  }
+
+  unbind() {
+    const _this$context2 = this.context,
+          database = _this$context2.database,
+          collection = _this$context2.collection; // 如果关系字段还没建立就删除了，也同步删除待建立关联的关系字段
+
+    database.removePendingField(this); // 删掉 model 的关联字段
+
+    delete collection.model.associations[this.name];
+  }
+
 }
-exports.BelongsToManyField = BelongsToManyField;
-//# sourceMappingURL=belongs-to-many-field.js.map
+
+exports.BelongsToManyField = BelongsToManyField;

package/lib/fields/boolean-field.js

@@ -1,12 +1,27 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.BooleanField = void 0;
-const sequelize_1 = require("sequelize");
-const field_1 = require("./field");
-class BooleanField extends field_1.Field {
-    get dataType() {
-        return sequelize_1.DataTypes.BOOLEAN;
-    }
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
 }
-exports.BooleanField = BooleanField;
-//# sourceMappingURL=boolean-field.js.map
+
+var _field = require("./field");
+
+class BooleanField extends _field.Field {
+  get dataType() {
+    return _sequelize().DataTypes.BOOLEAN;
+  }
+
+}
+
+exports.BooleanField = BooleanField;

package/lib/fields/context-field.js

@@ -1,50 +1,82 @@
 "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 });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.ContextField = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const sequelize_1 = require("sequelize");
-const field_1 = require("./field");
-class ContextField extends field_1.Field {
-    get dataType() {
-        const type = this.options.dataType || 'string';
-        return sequelize_1.DataTypes[type.toUpperCase()] || sequelize_1.DataTypes.STRING;
-    }
-    init() {
-        const { name, dataIndex } = this.options;
-        this.listener = (model, options) => __awaiter(this, void 0, void 0, function* () {
-            const { context } = options;
-            model.set(name, lodash_1.default.get(context, dataIndex));
-            model.changed(name, true);
-        });
-    }
-    bind() {
-        super.bind();
-        const { createOnly } = this.options;
-        this.on('beforeCreate', this.listener);
-        if (!createOnly) {
-            this.on('beforeUpdate', this.listener);
-        }
+
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+var _field = require("./field");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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); }); }; }
+
+class ContextField extends _field.Field {
+  get dataType() {
+    const type = this.options.dataType || 'string';
+    return _sequelize().DataTypes[type.toUpperCase()] || _sequelize().DataTypes.STRING;
+  }
+
+  init() {
+    const _this$options = this.options,
+          name = _this$options.name,
+          dataIndex = _this$options.dataIndex;
+
+    this.listener = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (model, options) {
+        const context = options.context;
+        model.set(name, _lodash().default.get(context, dataIndex));
+        model.changed(name, true);
+      });
+
+      return function (_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+  }
+
+  bind() {
+    super.bind();
+    const createOnly = this.options.createOnly;
+    this.on('beforeCreate', this.listener);
+
+    if (!createOnly) {
+      this.on('beforeUpdate', this.listener);
     }
-    unbind() {
-        super.unbind();
-        const { createOnly } = this.options;
-        this.off('beforeCreate', this.listener);
-        if (!createOnly) {
-            this.off('beforeUpdate', this.listener);
-        }
+  }
+
+  unbind() {
+    super.unbind();
+    const createOnly = this.options.createOnly;
+    this.off('beforeCreate', this.listener);
+
+    if (!createOnly) {
+      this.off('beforeUpdate', this.listener);
     }
+  }
+
 }
-exports.ContextField = ContextField;
-//# sourceMappingURL=context-field.js.map
+
+exports.ContextField = ContextField;

package/lib/fields/date-field.js

@@ -1,12 +1,27 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.DateField = void 0;
-const sequelize_1 = require("sequelize");
-const field_1 = require("./field");
-class DateField extends field_1.Field {
-    get dataType() {
-        return sequelize_1.DataTypes.DATE;
-    }
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
 }
-exports.DateField = DateField;
-//# sourceMappingURL=date-field.js.map
+
+var _field = require("./field");
+
+class DateField extends _field.Field {
+  get dataType() {
+    return _sequelize().DataTypes.DATE;
+  }
+
+}
+
+exports.DateField = DateField;

package/lib/fields/field.d.ts

@@ -1,4 +1,4 @@
-import { DataType, ModelAttributeColumnOptions, ModelIndexesOptions, SyncOptions } from 'sequelize';
+import { DataType, ModelAttributeColumnOptions, ModelIndexesOptions, QueryInterfaceOptions, SyncOptions, Transactionable } from 'sequelize';
 import { Collection } from '../collection';
 import { Database } from '../database';
 export interface FieldContext {
@@ -29,6 +29,9 @@ export declare abstract class Field {
     on(eventName: string, listener: (...args: any[]) => void): this;
     off(eventName: string, listener: (...args: any[]) => void): this;
     get(name: string): any;
+    remove(): Field;
+    removeFromDb(options?: QueryInterfaceOptions): Promise<void>;
+    existsInDb(options?: Transactionable): Promise<boolean>;
     merge(obj: any): void;
     bind(): void;
     unbind(): void;