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

package/lib/mock-database.js

@@ -1,40 +1,75 @@
 "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'
+    },
+    timezone: process.env.DB_TIMEZONE
+  };
 }
-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);
+}

package/lib/model-hook.d.ts

@@ -2,11 +2,11 @@ import type { SequelizeHooks } from 'sequelize/types/lib/hooks';
 import Database from './database';
 export declare class ModelHook {
     database: Database;
-    boundEvent: Set<string>;
+    boundEvents: Set<string>;
     constructor(database: Database);
-    isModelHook(eventName: string | symbol): keyof SequelizeHooks | false;
+    match(event: string | Symbol): keyof SequelizeHooks | null;
     findModelName(hookArgs: any): any;
-    bindEvent(eventName: any): void;
-    hasBindEvent(eventName: any): boolean;
-    sequelizeHookBuilder(eventName: any): (...args: any[]) => Promise<void>;
+    bindEvent(type: any): void;
+    hasBoundEvent(type: any): boolean;
+    buildSequelizeHook(type: any): (...args: any[]) => Promise<void>;
 }

package/lib/model-hook.js

@@ -1,68 +1,117 @@
 "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.ModelHook = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const model_1 = require("./model");
-const { hooks } = require('sequelize/lib/hooks');
+
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+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 _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 _require = require('sequelize/lib/hooks'),
+      hooks = _require.hooks;
+
 class ModelHook {
-    constructor(database) {
-        this.boundEvent = new Set();
-        this.database = database;
+  constructor(database) {
+    this.database = void 0;
+    this.boundEvents = new Set();
+    this.database = database;
+  }
+
+  match(event) {
+    // NOTE: skip Symbol event
+    if (!_lodash().default.isString(event)) {
+      return null;
     }
-    isModelHook(eventName) {
-        if (lodash_1.default.isString(eventName)) {
-            const hookType = eventName.split('.').pop();
-            if (hooks[hookType]) {
-                return hookType;
-            }
+
+    const type = event.split('.').pop();
+    return type in hooks ? type : null;
+  }
+
+  findModelName(hookArgs) {
+    var _iterator = _createForOfIteratorHelper(hookArgs),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const arg = _step.value;
+
+        if (arg === null || arg === void 0 ? void 0 : arg._previousDataValues) {
+          return arg.constructor.name;
         }
-        return false;
-    }
-    findModelName(hookArgs) {
-        for (const arg of hookArgs) {
-            if (arg instanceof model_1.Model) {
-                return arg.constructor.name;
-            }
-            if (lodash_1.default.isPlainObject(arg)) {
-                if (arg['model']) {
-                    return arg['model'].name;
-                }
-                if (lodash_1.default.get(arg, 'name.plural')) {
-                    return lodash_1.default.get(arg, 'name.plural');
-                }
-            }
+
+        if (_lodash().default.isPlainObject(arg)) {
+          var _arg$name, _arg$name2;
+
+          if (arg['model']) {
+            return arg['model'].name;
+          }
+
+          const plural = arg === null || arg === void 0 ? void 0 : (_arg$name = arg.name) === null || _arg$name === void 0 ? void 0 : _arg$name.plural;
+
+          if (this.database.sequelize.isDefined(plural)) {
+            return plural;
+          }
+
+          const singular = arg === null || arg === void 0 ? void 0 : (_arg$name2 = arg.name) === null || _arg$name2 === void 0 ? void 0 : _arg$name2.singular;
+
+          if (this.database.sequelize.isDefined(singular)) {
+            return singular;
+          }
         }
-        return null;
-    }
-    bindEvent(eventName) {
-        this.boundEvent.add(eventName);
-    }
-    hasBindEvent(eventName) {
-        return this.boundEvent.has(eventName);
-    }
-    sequelizeHookBuilder(eventName) {
-        return (...args) => __awaiter(this, void 0, void 0, function* () {
-            const modelName = this.findModelName(args);
-            if (modelName) {
-                // emit model event
-                yield this.database.emitAsync(`${modelName}.${eventName}`, ...args);
-            }
-            // emit sequelize global event
-            yield this.database.emitAsync(eventName, ...args);
-        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
     }
+
+    return null;
+  }
+
+  bindEvent(type) {
+    this.boundEvents.add(type);
+  }
+
+  hasBoundEvent(type) {
+    return this.boundEvents.has(type);
+  }
+
+  buildSequelizeHook(type) {
+    var _this = this;
+
+    return /*#__PURE__*/_asyncToGenerator(function* (...args) {
+      const modelName = _this.findModelName(args);
+
+      if (modelName) {
+        // emit model event
+        yield _this.database.emitAsync(`${modelName}.${type}`, ...args);
+      } // emit sequelize global event
+
+
+      yield _this.database.emitAsync(type, ...args);
+    });
+  }
+
 }
-exports.ModelHook = ModelHook;
-//# sourceMappingURL=model-hook.js.map
+
+exports.ModelHook = ModelHook;

package/lib/model.js

@@ -1,87 +1,122 @@
 "use strict";
-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.Model = void 0;
-const sequelize_1 = require("sequelize");
-const lodash_1 = __importDefault(require("lodash"));
-class Model extends sequelize_1.Model {
-    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];
-                }
-            }
-            return result;
-        };
-        return traverseJSON(super.toJSON(), opts);
-    }
-    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);
-    }
-    sortAssociations(data, { field }) {
-        const sortBy = field.options.sortBy;
-        return sortBy ? this.sortArray(data, sortBy) : data;
-    }
-    sortArray(data, sortBy) {
-        if (!lodash_1.default.isArray(sortBy)) {
-            sortBy = [sortBy];
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+function _lodash() {
+  const data = _interopRequireDefault(require("lodash"));
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Model extends _sequelize().Model {
+  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 = options.model,
+            db = options.db,
+            collection = options.collection; // handle Object
+
+      data = handleObj(data, options);
+      const result = {};
+
+      for (var _i = 0, _Object$keys = Object.keys(data); _i < _Object$keys.length; _i++) {
+        const key = _Object$keys[_i];
+
+        // @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];
         }
-        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);
+      }
+
+      return result;
+    };
+
+    return traverseJSON(super.toJSON(), opts);
+  }
+
+  hiddenObjKey(obj, options) {
+    const hiddenFields = Array.from(options.collection.fields.values()).filter(field => field.options.hidden).map(field => field.options.name);
+    return _lodash().default.omit(obj, hiddenFields);
+  }
+
+  sortAssociations(data, {
+    field
+  }) {
+    const sortBy = field.options.sortBy;
+    return sortBy ? this.sortArray(data, sortBy) : data;
+  }
+
+  sortArray(data, sortBy) {
+    if (!_lodash().default.isArray(sortBy)) {
+      sortBy = [sortBy];
     }
+
+    const orderItems = [];
+    const orderDirections = [];
+    sortBy.forEach(sortItem => {
+      orderDirections.push(sortItem.startsWith('-') ? 'desc' : 'asc');
+      orderItems.push(sortItem.replace('-', ''));
+    });
+    return _lodash().default.orderBy(data, orderItems, orderDirections);
+  }
+
 }
+
 exports.Model = Model;
-//# sourceMappingURL=model.js.map
+Model.database = void 0;
+Model.collection = void 0;