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

package/lib/options-parser.js

@@ -19,18 +19,18 @@ var _filterParser = _interopRequireDefault(require("./filter-parser"));
 
 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; }
-
 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 _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 debug = require('debug')('noco-database');
 
 class OptionsParser {
@@ -94,23 +94,45 @@ class OptionsParser {
       sort = sort.split(',');
     }
 
-    const orderParams = sort.map(sortKey => {
-      const direction = sortKey.startsWith('-') ? 'DESC' : 'ASC';
-      const sortField = sortKey.replace('-', '').split('.'); // handle sort by association
+    const orderParams = [];
+
+    var _iterator = _createForOfIteratorHelper(sort),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        const sortKey = _step.value;
+        let direction = sortKey.startsWith('-') ? 'DESC' : 'ASC';
+        let sortField = sortKey.replace('-', '').split('.');
+
+        if (this.database.inDialect('postgres', 'sqlite')) {
+          direction = `${direction} NULLS LAST`;
+        } // handle sort by association
+
 
-      if (sortField.length > 1) {
-        let associationModel = this.model;
+        if (sortField.length > 1) {
+          let associationModel = this.model;
 
-        for (let i = 0; i < sortField.length - 1; i++) {
-          const associationKey = sortField[i];
-          sortField[i] = associationModel.associations[associationKey].target;
-          associationModel = sortField[i];
+          for (let i = 0; i < sortField.length - 1; i++) {
+            const associationKey = sortField[i];
+            sortField[i] = associationModel.associations[associationKey].target;
+            associationModel = sortField[i];
+          }
         }
-      }
 
-      sortField.push(direction);
-      return sortField;
-    });
+        sortField.push(direction);
+
+        if (this.database.inDialect('mysql')) {
+          orderParams.push([_sequelize().Sequelize.fn('ISNULL', _sequelize().Sequelize.col(`${this.model.name}.${sortField[0]}`))]);
+        }
+
+        orderParams.push(sortField);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
 
     if (orderParams.length > 0) {
       return _objectSpread({
@@ -133,12 +155,12 @@ class OptionsParser {
 
     if ((_this$options4 = this.options) === null || _this$options4 === void 0 ? void 0 : _this$options4.fields) {
       // 将fields拆分为 attributes 和 appends
-      var _iterator = _createForOfIteratorHelper(this.options.fields),
-          _step;
+      var _iterator2 = _createForOfIteratorHelper(this.options.fields),
+          _step2;
 
       try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          const field = _step.value;
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          const field = _step2.value;
 
           if (this.isAssociationPath(field)) {
             // field is association field
@@ -150,19 +172,19 @@ class OptionsParser {
           }
         }
       } catch (err) {
-        _iterator.e(err);
+        _iterator2.e(err);
       } finally {
-        _iterator.f();
+        _iterator2.f();
       }
     }
 
     if ((_this$options5 = this.options) === null || _this$options5 === void 0 ? void 0 : _this$options5.except) {
-      var _iterator2 = _createForOfIteratorHelper(this.options.except),
-          _step2;
+      var _iterator3 = _createForOfIteratorHelper(this.options.except),
+          _step3;
 
       try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          const exceptKey = _step2.value;
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          const exceptKey = _step3.value;
 
           if (this.isAssociationPath(exceptKey)) {
             // except association field
@@ -174,9 +196,9 @@ class OptionsParser {
           }
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator3.e(err);
       } finally {
-        _iterator2.f();
+        _iterator3.f();
       }
     }
 
@@ -218,18 +240,18 @@ class OptionsParser {
       }
     };
 
-    var _iterator3 = _createForOfIteratorHelper(except),
-        _step3;
+    var _iterator4 = _createForOfIteratorHelper(except),
+        _step4;
 
     try {
-      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-        const exceptKey = _step3.value;
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        const exceptKey = _step4.value;
         setExcept(filterParams, exceptKey);
       }
     } catch (err) {
-      _iterator3.e(err);
+      _iterator4.e(err);
     } finally {
-      _iterator3.f();
+      _iterator4.f();
     }
 
     return filterParams;
@@ -317,18 +339,18 @@ class OptionsParser {
     }; // handle every appends
 
 
-    var _iterator4 = _createForOfIteratorHelper(appends),
-        _step4;
+    var _iterator5 = _createForOfIteratorHelper(appends),
+        _step5;
 
     try {
-      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-        const append = _step4.value;
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        const append = _step5.value;
         setInclude(this.model, filterParams, append);
       }
     } catch (err) {
-      _iterator4.e(err);
+      _iterator5.e(err);
     } finally {
-      _iterator4.f();
+      _iterator5.f();
     }
 
     debug('filter params: %o', filterParams);

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

@@ -37,6 +37,14 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try
 
 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); }); }; }
 
+var __decorate = void 0 && (void 0).__decorate || function (decorators, target, key, desc) {
+  var c = arguments.length,
+      r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
+      d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
 const transaction = (0, _transactionDecorator.transactionWrapperBuilder)(function () {
   return this.sourceCollection.model.sequelize.transaction();
 });
@@ -157,4 +165,6 @@ class RelationRepository {
 
 }
 
-exports.RelationRepository = RelationRepository;
+exports.RelationRepository = RelationRepository;
+
+__decorate([transaction()], RelationRepository.prototype, "create", null);

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

@@ -86,7 +86,9 @@ class SingleRelationRepository extends _relationRepository.RelationRepository {
     var _this4 = this;
 
     return _asyncToGenerator(function* () {
-      return _this4.find(options);
+      return _this4.find(_objectSpread(_objectSpread({}, options), {}, {
+        filterByTk: null
+      }));
     })();
   }
 
@@ -113,6 +115,11 @@ class SingleRelationRepository extends _relationRepository.RelationRepository {
       const target = yield _this6.find({
         transaction
       });
+
+      if (!target) {
+        throw new Error('The record does not exist');
+      }
+
       yield (0, _updateAssociations.updateModelByValues)(target, options === null || options === void 0 ? void 0 : options.values, _objectSpread(_objectSpread({}, _lodash().default.omit(options, 'values')), {}, {
         transaction
       }));

package/lib/repository.js

@@ -257,8 +257,12 @@ class Repository {
       }));
 
       if (options.hooks !== false) {
-        yield _this5.database.emitAsync(`${_this5.collection.name}.afterCreateWithAssociations`, instance, options);
-        yield _this5.database.emitAsync(`${_this5.collection.name}.afterSaveWithAssociations`, instance, options);
+        yield _this5.database.emitAsync(`${_this5.collection.name}.afterCreateWithAssociations`, instance, _objectSpread(_objectSpread({}, options), {}, {
+          transaction
+        }));
+        yield _this5.database.emitAsync(`${_this5.collection.name}.afterSaveWithAssociations`, instance, _objectSpread(_objectSpread({}, options), {}, {
+          transaction
+        }));
       }
 
       return instance;
@@ -349,8 +353,12 @@ class Repository {
         try {
           for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
             const instance = _step3.value;
-            yield _this7.database.emitAsync(`${_this7.collection.name}.afterUpdateWithAssociations`, instance, options);
-            yield _this7.database.emitAsync(`${_this7.collection.name}.afterSaveWithAssociations`, instance, options);
+            yield _this7.database.emitAsync(`${_this7.collection.name}.afterUpdateWithAssociations`, instance, _objectSpread(_objectSpread({}, options), {}, {
+              transaction
+            }));
+            yield _this7.database.emitAsync(`${_this7.collection.name}.afterSaveWithAssociations`, instance, _objectSpread(_objectSpread({}, options), {}, {
+              transaction
+            }));
           }
         } catch (err) {
           _iterator3.e(err);

package/lib/update-associations.js

@@ -364,7 +364,7 @@ function _updateSingleAssociation() {
 
         dataKey = association.targetKey;
       } else {
-        M = association.source;
+        M = association.target;
         dataKey = M.primaryKeyAttribute;
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/database",
-  "version": "0.7.0-alpha.82",
+  "version": "0.7.1-alpha.4",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -12,17 +12,22 @@
     }
   ],
   "dependencies": {
-    "@nocobase/utils": "0.7.0-alpha.82",
+    "@nocobase/utils": "0.7.1-alpha.4",
     "async-mutex": "^0.3.2",
     "deepmerge": "^4.2.2",
     "flat": "^5.0.2",
     "glob": "^7.1.6",
-    "sequelize": "^6.9.0"
+    "mathjs": "^10.6.1",
+    "sequelize": "^6.9.0",
+    "umzug": "^3.1.1"
+  },
+  "devDependencies": {
+    "@types/glob": "^7.2.0"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "4820fd09375c7200d1ea0bb0aab1bd4783b80d3d"
+  "gitHead": "570d039f1904a041729c1967c0637b1109c278a8"
 }

package/src/__tests__/collection.test.ts

@@ -13,6 +13,33 @@ describe('collection', () => {
     await db.close();
   });
 
+  test('removeFromDb', async () => {
+    await db.clean({ drop: true });
+    const collection = db.collection({
+      name: 'test',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+      ],
+    });
+    await db.sync();
+
+    const field = collection.getField('name');
+    const r1 = await field.existsInDb();
+    expect(r1).toBe(true);
+    await field.removeFromDb();
+    const r2 = await field.existsInDb();
+    expect(r2).toBe(false);
+
+    const r3 = await collection.existsInDb();
+    expect(r3).toBe(true);
+    await collection.removeFromDb();
+    const r4 = await collection.existsInDb();
+    expect(r4).toBe(false);
+  });
+
   test('collection disable authGenId', async () => {
     const Test = db.collection({
       name: 'test',

package/src/__tests__/database.test.ts

@@ -204,6 +204,53 @@ describe('database', () => {
     expect(listener).toHaveBeenCalled();
   });
 
+  test('off collection event', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'string', name: 'title' }],
+    });
+
+    const postAfterCreateListener = jest.fn();
+
+    db.on('posts.afterCreate', postAfterCreateListener);
+
+    await db.sync();
+
+    db.off('posts.afterCreate', postAfterCreateListener);
+
+    await Post.repository.create({
+      values: {
+        title: 'test',
+      },
+    });
+
+    expect(postAfterCreateListener).toHaveBeenCalledTimes(0);
+  });
+
+  test('off global event', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'string', name: 'title' }],
+    });
+
+    const postAfterCreateListener = jest.fn();
+
+    db.on('posts.afterCreate', postAfterCreateListener);
+    db.on('afterCreate', postAfterCreateListener);
+
+    await db.sync();
+
+    db.off('afterCreate', postAfterCreateListener);
+
+    await Post.repository.create({
+      values: {
+        title: 'test',
+      },
+    });
+
+    expect(postAfterCreateListener).toHaveBeenCalledTimes(1);
+  });
+
   test('custom model', async () => {
     class CustomModel extends Model {
       customMethod() {

package/src/__tests__/fields/formula-field.test.ts

@@ -0,0 +1,69 @@
+import { mockDatabase } from '..';
+import { Database } from '../../database';
+import { FormulaField } from '../../fields';
+
+describe('formula field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('add formula field with old table, already has data.', async () => {
+    const Test = db.collection({
+      name: 'tests',
+      fields: [
+        { type: 'float', name: 'price' },
+        { type: 'float', name: 'count' },
+      ],
+    });
+
+    await db.sync();
+
+    const test = await Test.model.create<any>({
+      price: '1.2',
+      count: '2',
+    });
+
+    const expression = 'price*count';
+    const field = Test.addField('sum', { type: 'formula', expression });
+
+    await field.sync({});
+
+    const updatedTest = await Test.model.findByPk(test.id);
+    const sum = updatedTest.get('sum');
+
+    const sumField = Test.getField<FormulaField>('sum');
+    expect(sum).toEqual(sumField.caculate(expression, updatedTest.toJSON()));
+  });
+
+  it('auto set formula field with create or update data', async () => {
+    const expression = 'price*count';
+    const Test = db.collection({
+      name: 'tests',
+      fields: [
+        { type: 'float', name: 'price' },
+        { type: 'float', name: 'count' },
+        { name: 'sum', type: 'formula', expression },
+      ],
+    });
+
+    await db.sync();
+
+    const test = await Test.model.create<any>({
+      price: '1.2',
+      count: '2',
+    });
+
+    const sumField = Test.getField<FormulaField>('sum');
+    expect(test.get('sum')).toEqual(sumField.caculate(expression, test.toJSON()));
+
+    test.set('count', '6');
+    await test.save();
+    expect(test.get('sum')).toEqual(sumField.caculate(expression, test.toJSON()));
+  });
+});

package/src/__tests__/fixtures/migrations/m1.ts

@@ -0,0 +1,7 @@
+import { Migration } from '@nocobase/database';
+
+export default class extends Migration {
+  async up() {}
+
+  async down() {}
+}

package/src/__tests__/fixtures/migrations/m2.ts

@@ -0,0 +1,7 @@
+import { Migration } from '@nocobase/database';
+
+export default class extends Migration {
+  async up() {}
+
+  async down() {}
+}

package/src/__tests__/hooks/afterCreateWithAssociations.test.ts

@@ -0,0 +1,33 @@
+import { mockDatabase } from '../';
+import { Database } from '../../database';
+
+describe('afterCreateWithAssociations', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  test('case 1', async () => {
+    db.collection({
+      name: 'test',
+    });
+    await db.sync();
+    const repo = db.getRepository('test');
+    db.on('test.afterCreateWithAssociations', async (model, { transaction }) => {
+      throw new Error('test error');
+    });
+    try {
+      await repo.create({
+        values: {},
+      });
+    } catch (error) {
+    }
+    const count = await repo.count();
+    expect(count).toBe(0);
+  });
+});

package/src/__tests__/migrator.test.ts

@@ -0,0 +1,70 @@
+import { Database, Migration, mockDatabase } from '@nocobase/database';
+import { resolve } from 'path';
+
+const names = (migrations: Array<{ name: string }>) => migrations.map(m => m.name);
+
+describe('migrator', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+
+    db = mockDatabase({
+      tablePrefix: 'test_',
+    });
+
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  test('addMigrations', async () => {
+    db.addMigrations({
+      directory: resolve(__dirname, './fixtures/migrations'),
+    });
+    await db.migrator.up();
+    expect(names(await db.migrator.executed())).toEqual(['m1', 'm2']);
+  });
+
+  test('addMigrations', async () => {
+    db.addMigrations({
+      namespace: 'test',
+      directory: resolve(__dirname, './fixtures/migrations'),
+    });
+    await db.migrator.up();
+    expect(names(await db.migrator.executed())).toEqual(['test/m1', 'test/m2']);
+  });
+
+  test('up and down', async () => {
+    const spy = jest.fn();
+    db.addMigration({
+      name: 'migration1',
+      migration: class extends Migration {
+        async up() {
+          spy('migration1-up');
+        }
+        async down() {
+          spy('migration1-down');
+        }
+      },
+    });
+    db.addMigration({
+      name: 'migration2',
+      migration: class extends Migration {
+        async up() {
+          spy('migration2-up');
+        }
+        async down() {
+          spy('migration2-down');
+        }
+      },
+    });
+    await db.migrator.up();
+    expect(names(await db.migrator.executed())).toEqual(['migration1', 'migration2']);
+    await db.migrator.down();
+    expect(names(await db.migrator.executed())).toEqual(['migration1']);
+    expect(spy).toHaveBeenCalledTimes(3);
+    expect(spy).toHaveBeenNthCalledWith(1, 'migration1-up');
+  });
+});

package/src/__tests__/model-hook.test.ts

@@ -0,0 +1,54 @@
+import { Database } from '..';
+import { mockDatabase } from '.';
+
+describe('model hook', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  describe('match', () => {
+    test('sequelize db hooks', async () => {
+      const matcher = db.modelHook.match('beforeDefine');
+      expect(matcher).toEqual('beforeDefine');
+    });
+
+    test('sequelize global model hooks', async () => {
+      const matcher = db.modelHook.match('beforeCreate');
+      expect(matcher).toEqual('beforeCreate');
+    });
+
+    test('sequelize model hooks without existing collection', async () => {
+      const matcher = db.modelHook.match('posts.beforeCreate');
+      expect(matcher).toEqual('beforeCreate');
+    });
+
+    test('sequelize model hooks with existing collection', async () => {
+      db.collection({
+        name: 'posts',
+        fields: []
+      });
+      const matcher = db.modelHook.match('posts.beforeCreate');
+      expect(matcher).toEqual('beforeCreate');
+    });
+
+    test('customized global hooks', async () => {
+      const matcher = db.modelHook.match('beforeDefineCollection');
+      expect(matcher).toBeNull();
+    });
+
+    test('customized model hooks', async () => {
+      db.collection({
+        name: 'posts',
+        fields: []
+      });
+      const matcher = db.modelHook.match('posts.beforeCreateWithAssociations');
+      expect(matcher).toBeNull();
+    });
+  });
+});