@nocobase/database 0.7.0-alpha.6 → 0.7.0-alpha.62

package/lib/index.js

@@ -1,31 +1,212 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Op: true
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.Op = void 0;
-var sequelize_1 = require("sequelize");
-Object.defineProperty(exports, "Op", { enumerable: true, get: function () { return sequelize_1.Op; } });
-__exportStar(require("./collection"), exports);
-__exportStar(require("./database"), exports);
-var database_1 = require("./database");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return database_1.Database; } });
-__exportStar(require("./fields"), exports);
-__exportStar(require("./magic-attribute-model"), exports);
-__exportStar(require("./mock-database"), exports);
-__exportStar(require("./model"), exports);
-__exportStar(require("./relation-repository/belongs-to-many-repository"), exports);
-__exportStar(require("./relation-repository/belongs-to-repository"), exports);
-__exportStar(require("./relation-repository/hasmany-repository"), exports);
-__exportStar(require("./relation-repository/multiple-relation-repository"), exports);
-__exportStar(require("./relation-repository/single-relation-repository"), exports);
-__exportStar(require("./repository"), exports);
-__exportStar(require("./update-associations"), exports);
-//# sourceMappingURL=index.js.map
+Object.defineProperty(exports, "Op", {
+  enumerable: true,
+  get: function get() {
+    return _sequelize().Op;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _database.Database;
+  }
+});
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+var _collection = require("./collection");
+
+Object.keys(_collection).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _collection[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _collection[key];
+    }
+  });
+});
+
+var _database = require("./database");
+
+Object.keys(_database).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _database[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _database[key];
+    }
+  });
+});
+
+var _fields = require("./fields");
+
+Object.keys(_fields).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _fields[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _fields[key];
+    }
+  });
+});
+
+var _magicAttributeModel = require("./magic-attribute-model");
+
+Object.keys(_magicAttributeModel).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _magicAttributeModel[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _magicAttributeModel[key];
+    }
+  });
+});
+
+var _mockDatabase = require("./mock-database");
+
+Object.keys(_mockDatabase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _mockDatabase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _mockDatabase[key];
+    }
+  });
+});
+
+var _model = require("./model");
+
+Object.keys(_model).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _model[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _model[key];
+    }
+  });
+});
+
+var _belongsToManyRepository = require("./relation-repository/belongs-to-many-repository");
+
+Object.keys(_belongsToManyRepository).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _belongsToManyRepository[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _belongsToManyRepository[key];
+    }
+  });
+});
+
+var _belongsToRepository = require("./relation-repository/belongs-to-repository");
+
+Object.keys(_belongsToRepository).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _belongsToRepository[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _belongsToRepository[key];
+    }
+  });
+});
+
+var _hasmanyRepository = require("./relation-repository/hasmany-repository");
+
+Object.keys(_hasmanyRepository).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _hasmanyRepository[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _hasmanyRepository[key];
+    }
+  });
+});
+
+var _multipleRelationRepository = require("./relation-repository/multiple-relation-repository");
+
+Object.keys(_multipleRelationRepository).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _multipleRelationRepository[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _multipleRelationRepository[key];
+    }
+  });
+});
+
+var _singleRelationRepository = require("./relation-repository/single-relation-repository");
+
+Object.keys(_singleRelationRepository).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _singleRelationRepository[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _singleRelationRepository[key];
+    }
+  });
+});
+
+var _repository = require("./repository");
+
+Object.keys(_repository).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _repository[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _repository[key];
+    }
+  });
+});
+
+var _updateAssociations = require("./update-associations");
+
+Object.keys(_updateAssociations).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _updateAssociations[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _updateAssociations[key];
+    }
+  });
+});

package/lib/magic-attribute-model.js

@@ -1,77 +1,129 @@
 "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.MagicAttributeModel = void 0;
-const utils_1 = require("@nocobase/utils");
-const lodash_1 = __importDefault(require("lodash"));
-const model_1 = require("./model");
-class MagicAttributeModel extends model_1.Model {
-    get magicAttribute() {
-        const db = this.constructor.database;
-        const collection = db.getCollection(this.constructor.name);
-        return collection.options.magicAttribute || 'options';
-    }
-    set(key, value, options) {
-        if (typeof key === 'string') {
-            const [column] = key.split('.');
-            if (this.constructor.hasAlias(column)) {
-                return super.set(key, value, options);
-            }
-            if (this.constructor.rawAttributes[column]) {
-                return super.set(key, value, options);
-            }
-            if (lodash_1.default.isPlainObject(value)) {
-                const opts = super.get(this.magicAttribute) || {};
-                return super.set(`${this.magicAttribute}.${key}`, (0, utils_1.merge)(opts === null || opts === void 0 ? void 0 : opts[key], value), options);
-            }
-            return super.set(`${this.magicAttribute}.${key}`, value, options);
-        }
-        else {
-            if (!key) {
-                return;
-            }
-            Object.keys(key).forEach((k) => {
-                this.set(k, key[k], options);
-            });
-        }
+
+function _utils() {
+  const data = require("@nocobase/utils");
+
+  _utils = function _utils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+var _model = require("./model");
+
+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); }); }; }
+
+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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+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; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+class MagicAttributeModel extends _model.Model {
+  get magicAttribute() {
+    const db = this.constructor.database;
+    const collection = db.getCollection(this.constructor.name);
+    return collection.options.magicAttribute || 'options';
+  }
+
+  set(key, value, options) {
+    if (typeof key === 'string') {
+      const _key$split = key.split('.'),
+            _key$split2 = _slicedToArray(_key$split, 1),
+            column = _key$split2[0];
+
+      if (this.constructor.hasAlias(column)) {
         return super.set(key, value, options);
+      }
+
+      if (this.constructor.rawAttributes[column]) {
+        return super.set(key, value, options);
+      }
+
+      if (_lodash().default.isPlainObject(value)) {
+        const opts = super.get(this.magicAttribute) || {};
+        return super.set(`${this.magicAttribute}.${key}`, (0, _utils().merge)(opts === null || opts === void 0 ? void 0 : opts[key], value), options);
+      }
+
+      return super.set(`${this.magicAttribute}.${key}`, value, options);
+    } else {
+      if (!key) {
+        return;
+      }
+
+      Object.keys(key).forEach(k => {
+        this.set(k, key[k], options);
+      });
     }
-    get(key, value) {
-        if (typeof key === 'string') {
-            const [column] = key.split('.');
-            if (this.constructor.hasAlias(column)) {
-                return super.get(key, value);
-            }
-            if (this.constructor.rawAttributes[column]) {
-                return super.get(key, value);
-            }
-            const options = super.get(this.magicAttribute, value);
-            return lodash_1.default.get(options, key);
-        }
-        const data = super.get(key, value);
-        return Object.assign(Object.assign({}, lodash_1.default.omit(data, this.magicAttribute)), data[this.magicAttribute]);
-    }
-    update(values, options) {
-        const _super = Object.create(null, {
-            update: { get: () => super.update }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            // @ts-ignore
-            this._changed = new Set();
-            return _super.update.call(this, values, options);
-        });
+
+    return super.set(key, value, options);
+  }
+
+  get(key, value) {
+    if (typeof key === 'string') {
+      const _key$split3 = key.split('.'),
+            _key$split4 = _slicedToArray(_key$split3, 1),
+            column = _key$split4[0];
+
+      if (this.constructor.hasAlias(column)) {
+        return super.get(key, value);
+      }
+
+      if (this.constructor.rawAttributes[column]) {
+        return super.get(key, value);
+      }
+
+      const options = super.get(this.magicAttribute, value);
+      return _lodash().default.get(options, key);
     }
+
+    const data = super.get(key, value);
+    return _objectSpread(_objectSpread({}, _lodash().default.omit(data, this.magicAttribute)), data[this.magicAttribute]);
+  }
+
+  update(values, options) {
+    var _superprop_getUpdate = () => super.update,
+        _this = this;
+
+    return _asyncToGenerator(function* () {
+      // @ts-ignore
+      _this._changed = new Set();
+      return _superprop_getUpdate().call(_this, values, options);
+    })();
+  }
+
 }
-exports.MagicAttributeModel = MagicAttributeModel;
-//# sourceMappingURL=magic-attribute-model.js.map
+
+exports.MagicAttributeModel = MagicAttributeModel;

package/lib/mock-database.js

@@ -1,40 +1,74 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockDatabase = exports.getConfigByEnv = exports.MockDatabase = void 0;
-const utils_1 = require("@nocobase/utils");
-const path_1 = require("path");
-const database_1 = require("./database");
-class MockDatabase extends database_1.Database {
-    constructor(options) {
-        super(Object.assign({ storage: ':memory:', tablePrefix: `mock_${(0, utils_1.uid)(6)}_`, dialect: 'sqlite' }, options));
-        this.sequelize.beforeDefine((model, opts) => {
-            opts.tableName = `${this.getTablePrefix()}${opts.tableName || opts.modelName || opts.name.plural}`;
-        });
-    }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MockDatabase = void 0;
+exports.getConfigByEnv = getConfigByEnv;
+exports.mockDatabase = mockDatabase;
+
+function _utils() {
+  const data = require("@nocobase/utils");
+
+  _utils = function _utils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _path() {
+  const data = require("path");
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+var _database = require("./database");
+
+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 MockDatabase extends _database.Database {
+  constructor(options) {
+    super(_objectSpread({
+      storage: ':memory:',
+      tablePrefix: `mock_${(0, _utils().uid)(6)}_`,
+      dialect: 'sqlite'
+    }, options));
+    this.sequelize.beforeDefine((model, opts) => {
+      opts.tableName = `${this.getTablePrefix()}${opts.tableName || opts.modelName || opts.name.plural}`;
+    });
+  }
+
 }
+
 exports.MockDatabase = MockDatabase;
+
 function getConfigByEnv() {
-    return {
-        username: process.env.DB_USER,
-        password: process.env.DB_PASSWORD,
-        database: process.env.DB_DATABASE,
-        host: process.env.DB_HOST,
-        port: process.env.DB_PORT,
-        dialect: process.env.DB_DIALECT,
-        logging: process.env.DB_LOG_SQL === 'on' ? console.log : false,
-        storage: process.env.DB_STORAGE && process.env.DB_STORAGE !== ':memory:'
-            ? (0, path_1.resolve)(process.cwd(), process.env.DB_STORAGE)
-            : ':memory:',
-        define: {
-            charset: 'utf8mb4',
-            collate: 'utf8mb4_unicode_ci',
-        },
-    };
+  return {
+    username: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    database: process.env.DB_DATABASE,
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    dialect: process.env.DB_DIALECT,
+    logging: process.env.DB_LOGGING === 'on' ? console.log : false,
+    storage: process.env.DB_STORAGE && process.env.DB_STORAGE !== ':memory:' ? (0, _path().resolve)(process.cwd(), process.env.DB_STORAGE) : ':memory:',
+    define: {
+      charset: 'utf8mb4',
+      collate: 'utf8mb4_unicode_ci'
+    }
+  };
 }
-exports.getConfigByEnv = getConfigByEnv;
+
 function mockDatabase(options = {}) {
-    const dbOptions = (0, utils_1.merge)(getConfigByEnv(), options);
-    return new MockDatabase(dbOptions);
-}
-exports.mockDatabase = mockDatabase;
-//# sourceMappingURL=mock-database.js.map
+  const dbOptions = (0, _utils().merge)(getConfigByEnv(), options);
+  return new MockDatabase(dbOptions);
+}