@nocobase/database 0.8.0-alpha.8 → 0.8.1-alpha.3

package/lib/sync-runner.js

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SyncRunner = void 0;
+
+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 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; }
+
+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 SyncRunner {
+  static syncInheritModel(model, options) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const transaction = options.transaction;
+      const inheritedCollection = model.collection;
+      const db = inheritedCollection.context.database;
+      const dialect = db.sequelize.getDialect();
+      const queryInterface = db.sequelize.getQueryInterface();
+
+      if (dialect != 'postgres') {
+        throw new Error('Inherit model is only supported on postgres');
+      }
+
+      const parents = inheritedCollection.parents;
+
+      if (!parents) {
+        throw new Error(`Inherit model ${inheritedCollection.name} can't be created without parents, parents option is ${_lodash().default.castArray(inheritedCollection.options.inherits).join(', ')}`);
+      }
+
+      const parentTables = parents.map(parent => parent.model.tableName);
+      const tableName = model.getTableName();
+      const attributes = model.tableAttributes;
+
+      const childAttributes = _lodash().default.pickBy(attributes, value => {
+        return !value.inherit;
+      });
+
+      let maxSequenceVal = 0;
+      let maxSequenceName;
+
+      if (childAttributes.id && childAttributes.id.autoIncrement) {
+        var _iterator = _createForOfIteratorHelper(parentTables),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            const parent = _step.value;
+            const sequenceNameResult = yield queryInterface.sequelize.query(`SELECT column_default FROM information_schema.columns WHERE 
+          table_name='${parent}' and "column_name" = 'id';`, {
+              transaction
+            });
+
+            if (!sequenceNameResult[0].length) {
+              continue;
+            }
+
+            const columnDefault = sequenceNameResult[0][0]['column_default'];
+
+            if (!columnDefault) {
+              throw new Error(`Can't find sequence name of ${parent}`);
+            }
+
+            const regex = new RegExp(/nextval\('("?\w+"?)\'.*\)/);
+            const match = regex.exec(columnDefault);
+            const sequenceName = match[1];
+            const sequenceCurrentValResult = yield queryInterface.sequelize.query(`select last_value from ${sequenceName}`, {
+              transaction
+            });
+            const sequenceCurrentVal = parseInt(sequenceCurrentValResult[0][0]['last_value']);
+
+            if (sequenceCurrentVal > maxSequenceVal) {
+              maxSequenceName = sequenceName;
+              maxSequenceVal = sequenceCurrentVal;
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+
+      yield _this.createTable(tableName, childAttributes, options, model, parentTables);
+
+      if (maxSequenceName) {
+        const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map(parent => db.getCollection(parent).model.tableName);
+        const sequenceTables = [...parentsDeep, tableName];
+
+        for (var _i = 0, _sequenceTables = sequenceTables; _i < _sequenceTables.length; _i++) {
+          const sequenceTable = _sequenceTables[_i];
+          const queryName = Boolean(sequenceTable.match(/[A-Z]/)) ? `"${sequenceTable}"` : sequenceTable;
+          const idColumnQuery = yield queryInterface.sequelize.query(`
+SELECT true
+FROM   pg_attribute 
+WHERE  attrelid = '${queryName}'::regclass  -- cast to a registered class (table)
+AND    attname = 'id'
+AND    NOT attisdropped 
+`, {
+            transaction
+          });
+
+          if (idColumnQuery[0].length == 0) {
+            continue;
+          }
+
+          yield queryInterface.sequelize.query(`alter table "${sequenceTable}" alter column id set default nextval('${maxSequenceName}')`, {
+            transaction
+          });
+        }
+      }
+
+      if (options.alter) {
+        const columns = yield queryInterface.describeTable(tableName, options);
+
+        for (const columnName in childAttributes) {
+          if (!columns[columnName]) {
+            yield queryInterface.addColumn(tableName, columnName, childAttributes[columnName], options);
+          }
+        }
+      }
+    })();
+  }
+
+  static createTable(tableName, attributes, options, model, parentTables) {
+    return _asyncToGenerator(function* () {
+      let sql = '';
+      options = _objectSpread({}, options);
+
+      if (options && options.uniqueKeys) {
+        _lodash().default.forOwn(options.uniqueKeys, uniqueKey => {
+          if (uniqueKey.customIndex === undefined) {
+            uniqueKey.customIndex = true;
+          }
+        });
+      }
+
+      if (model) {
+        options.uniqueKeys = options.uniqueKeys || model.uniqueKeys;
+      }
+
+      const queryGenerator = model.queryGenerator;
+      attributes = _lodash().default.mapValues(attributes, attribute => model.sequelize.normalizeAttribute(attribute));
+      attributes = queryGenerator.attributesToSQL(attributes, {
+        table: tableName,
+        context: 'createTable'
+      });
+      sql = `${queryGenerator.createTableQuery(tableName, attributes, options)}`.replace(';', ` INHERITS (${parentTables.map(t => `"${t}"`).join(', ')});`);
+      return yield model.sequelize.query(sql, options);
+    })();
+  }
+
+}
+
+exports.SyncRunner = SyncRunner;

package/lib/types.d.ts

@@ -1,8 +1,8 @@
 import type { Model } from './model';
-import type { ValidationOptions } from 'sequelize/types/lib/instance-validator';
-import type { HookReturn } from 'sequelize/types/lib/hooks';
 import type { CreateOptions, DestroyOptions, SaveOptions, SyncOptions, UpdateOptions } from 'sequelize/types';
 import { Collection, CollectionOptions } from './collection';
+import { HookReturn } from 'sequelize/types/hooks';
+import { ValidationOptions } from 'sequelize/types/instance-validator';
 export declare type CollectionNameType = string;
 export declare type ModelSyncEventType = 'beforeSync' | 'afterSync';
 export declare type ModelValidateEventType = 'beforeValidate' | 'afterValidate';

package/lib/update-associations.d.ts

@@ -22,6 +22,7 @@ interface UpdateAssociationOptions extends Transactionable, Hookable {
     sourceModel?: Model;
     context?: any;
     associationContext?: any;
+    recursive?: boolean;
 }
 export declare function updateModelByValues(instance: Model, values: UpdateValue, options?: UpdateOptions): Promise<void>;
 export declare function updateThroughTableValue(instance: Model, throughName: string, throughValues: any, source: Model, transaction?: any): Promise<any>;

package/lib/update-associations.js

@@ -151,6 +151,10 @@ function _updateAssociations() {
       return;
     }
 
+    if (options === null || options === void 0 ? void 0 : options.updateAssociationValues) {
+      options.recursive = true;
+    }
+
     let newTransaction = false;
     let transaction = options.transaction;
 
@@ -306,7 +310,8 @@ function _updateSingleAssociation() {
       throw new Error(`The value of '${key}' cannot be in array format`);
     }
 
-    const context = options.context,
+    const recursive = options.recursive,
+          context = options.context,
           _options$updateAssoci = options.updateAssociationValues,
           updateAssociationValues = _options$updateAssoci === void 0 ? [] : _options$updateAssoci,
           transaction = options.transaction;
@@ -378,6 +383,10 @@ function _updateSingleAssociation() {
             transaction
           });
 
+          if (!recursive) {
+            return;
+          }
+
           if (updateAssociationValues.includes(key)) {
             yield instance.update(value, _objectSpread(_objectSpread({}, options), {}, {
               transaction
@@ -431,7 +440,8 @@ function _updateMultipleAssociation() {
       return false;
     }
 
-    const context = options.context,
+    const recursive = options.recursive,
+          context = options.context,
           _options$updateAssoci2 = options.updateAssociationValues,
           updateAssociationValues = _options$updateAssoci2 === void 0 ? [] : _options$updateAssoci2,
           transaction = options.transaction;
@@ -528,9 +538,18 @@ function _updateMultipleAssociation() {
           const instance = yield association.target.findByPk(item[pk], {
             transaction
           });
+
+          if (!instance) {
+            continue;
+          }
+
           const addAccessor = association.accessors.add;
           yield model[addAccessor](item[pk], accessorOptions);
 
+          if (!recursive) {
+            continue;
+          }
+
           if (updateAssociationValues.includes(key)) {
             yield instance.update(item, _objectSpread(_objectSpread({}, options), {}, {
               transaction

package/lib/update-guard.d.ts

@@ -1,4 +1,4 @@
-import { ModelCtor } from 'sequelize';
+import { ModelStatic } from 'sequelize';
 import { AssociationKeysToBeUpdate, BlackList, WhiteList } from './repository';
 declare type UpdateValueItem = string | number | UpdateValues;
 declare type UpdateValues = {
@@ -6,13 +6,13 @@ declare type UpdateValues = {
 };
 declare type UpdateAction = 'create' | 'update';
 export declare class UpdateGuard {
-    model: ModelCtor<any>;
+    model: ModelStatic<any>;
     action: UpdateAction;
     private associationKeysToBeUpdate;
     private blackList;
     private whiteList;
     setAction(action: UpdateAction): void;
-    setModel(model: ModelCtor<any>): void;
+    setModel(model: ModelStatic<any>): void;
     setAssociationKeysToBeUpdate(associationKeysToBeUpdate: AssociationKeysToBeUpdate): void;
     setWhiteList(whiteList: WhiteList): void;
     setBlackList(blackList: BlackList): void;

package/lib/utils.js

@@ -45,6 +45,11 @@ function _handleAppendsQuery() {
   _handleAppendsQuery = _asyncToGenerator(function* (options) {
     const templateModel = options.templateModel,
           queryPromises = options.queryPromises;
+
+    if (!templateModel) {
+      return [];
+    }
+
     const primaryKey = templateModel.constructor.primaryKeyAttribute;
     const results = yield Promise.all(queryPromises);
     let rows;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/database",
-  "version": "0.8.0-alpha.8",
+  "version": "0.8.1-alpha.3",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -12,7 +12,7 @@
     }
   ],
   "dependencies": {
-    "@nocobase/utils": "0.8.0-alpha.8",
+    "@nocobase/utils": "0.8.1-alpha.3",
     "async-mutex": "^0.3.2",
     "cron-parser": "4.4.0",
     "deepmerge": "^4.2.2",
@@ -21,7 +21,7 @@
     "mathjs": "^10.6.1",
     "moment": "2.x",
     "semver": "^7.3.7",
-    "sequelize": "^6.9.0",
+    "sequelize": "^6.26.0",
     "umzug": "^3.1.1"
   },
   "devDependencies": {
@@ -32,5 +32,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "d53b20e08591651692c37b8bfdf1bfe59332bbdb"
+  "gitHead": "e03df3df5962b99d9fbf5b6e33fbe2b23f14f3d3"
 }

package/src/__tests__/bigint.test.ts

@@ -0,0 +1,48 @@
+import { Database } from '../database';
+import { mockDatabase } from './index';
+
+const excludeSqlite = () => (process.env.DB_DIALECT != 'sqlite' ? describe : describe.skip);
+
+excludeSqlite()('collection', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase({
+      logging: console.log,
+    });
+
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should using bigint for id field', async () => {
+    const collection = db.collection({
+      name: 'users',
+      fields: [{ type: 'hasOne', name: 'profile' }],
+    });
+
+    await db.sync();
+    const tableInfo = await db.sequelize.getQueryInterface().describeTable(collection.model.tableName);
+
+    expect(tableInfo['id'].type).toBe('BIGINT');
+
+    const profile = db.collection({
+      name: 'profiles',
+      fields: [
+        {
+          type: 'belongsTo',
+          name: 'user',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    const profileTableInfo = await db.sequelize.getQueryInterface().describeTable(profile.model.tableName);
+
+    expect(profileTableInfo['userId'].type).toBe('BIGINT');
+  });
+});

package/src/__tests__/collection.test.ts

@@ -3,31 +3,66 @@ import { Database } from '../database';
 import { mockDatabase } from './index';
 import { IdentifierError } from '../errors/identifier-error';
 
+const pgOnly = () => (process.env.DB_DIALECT == 'postgres' ? it : it.skip);
 describe('collection', () => {
   let db: Database;
 
   beforeEach(async () => {
-    db = mockDatabase();
+    db = mockDatabase({
+      logging: console.log,
+    });
+
+    await db.clean({ drop: true });
   });
 
   afterEach(async () => {
     await db.close();
   });
 
-  test.skip('indexes', async () => {
-    await db.clean({ drop: true });
-    const collection = db.collection({
-      name: 'test',
-      fields: [
-        {
-          type: 'string',
-          name: 'name',
-          index: true,
+  it('should throw error when create empty collection in sqlite and mysql', async () => {
+    if (!db.inDialect('sqlite', 'mysql')) {
+      return;
+    }
+
+    db.collection({
+      name: 'empty',
+      timestamps: false,
+      autoGenId: false,
+      fields: [],
+    });
+
+    let error;
+
+    try {
+      await db.sync({
+        force: false,
+        alter: {
+          drop: false,
         },
-      ],
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error.message.includes("Zero-column tables aren't supported in")).toBeTruthy();
+  });
+
+  pgOnly()('can create empty collection', async () => {
+    db.collection({
+      name: 'empty',
+      timestamps: false,
+      autoGenId: false,
+      fields: [],
     });
-    collection.removeField('name');
-    await db.sync();
+
+    await db.sync({
+      force: false,
+      alter: {
+        drop: false,
+      },
+    });
+
+    expect(db.getCollection('empty')).toBeInstanceOf(Collection);
   });
 
   test('removeFromDb', async () => {

package/src/__tests__/database.test.ts

@@ -1,5 +1,6 @@
 import path from 'path';
 import { Database, Model } from '..';
+import { ArrayFieldRepository } from '../field-repository/array-field-repository';
 import { mockDatabase } from './index';
 
 describe('database', () => {
@@ -47,6 +48,15 @@ describe('database', () => {
     );
   });
 
+  it('should get array field repository', async () => {
+    db.collection({
+      name: 'tests',
+      fields: [{ type: 'set', name: 'set-field' }],
+    });
+
+    expect(db.getRepository('tests.set-field', '1')).toBeInstanceOf(ArrayFieldRepository);
+  });
+
   test('import', async () => {
     await db.import({
       directory: path.resolve(__dirname, './fixtures/collections'),

package/src/__tests__/field-repository/array-field-repository.test.ts

@@ -0,0 +1,94 @@
+import { mockDatabase } from '../index';
+import Database from '../../database';
+import { ArrayFieldRepository } from '../../field-repository/array-field-repository';
+
+describe('Array field repository', () => {
+  let db: Database;
+
+  let TestCollection;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    TestCollection = db.collection({
+      name: 'test',
+      fields: [
+        {
+          type: 'set',
+          name: 'set-field',
+        },
+      ],
+    });
+
+    await db.sync();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should add item into fields', async () => {
+    const a1 = await TestCollection.repository.create({});
+
+    const fieldRepository = new ArrayFieldRepository(TestCollection, 'set-field', a1.get('id'));
+    await fieldRepository.add({
+      values: 'a',
+    });
+
+    expect(await fieldRepository.get()).toEqual(['a']);
+  });
+
+  it('should remove item', async () => {
+    const a1 = await TestCollection.repository.create({});
+
+    const fieldRepository = new ArrayFieldRepository(TestCollection, 'set-field', a1.get('id'));
+    await fieldRepository.add({
+      values: ['a', 'b', 'c'],
+    });
+
+    expect(await fieldRepository.get()).toEqual(['a', 'b', 'c']);
+    await fieldRepository.remove({
+      values: ['c'],
+    });
+
+    expect(await fieldRepository.get()).toEqual(['a', 'b']);
+  });
+
+  it('should set items', async () => {
+    const a1 = await TestCollection.repository.create({});
+
+    const fieldRepository = new ArrayFieldRepository(TestCollection, 'set-field', a1.get('id'));
+    await fieldRepository.add({
+      values: ['a', 'b', 'c'],
+    });
+
+    expect(await fieldRepository.get()).toEqual(['a', 'b', 'c']);
+    await fieldRepository.set({
+      values: ['d', 'e'],
+    });
+
+    expect(await fieldRepository.get()).toEqual(['d', 'e']);
+  });
+
+  it('should toggle item', async () => {
+    const a1 = await TestCollection.repository.create({});
+
+    const fieldRepository = new ArrayFieldRepository(TestCollection, 'set-field', a1.get('id'));
+    await fieldRepository.add({
+      values: ['a', 'b', 'c'],
+    });
+
+    expect(await fieldRepository.get()).toEqual(['a', 'b', 'c']);
+
+    await fieldRepository.toggle({
+      value: 'c',
+    });
+
+    expect(await fieldRepository.get()).toEqual(['a', 'b']);
+
+    await fieldRepository.toggle({
+      value: 'c',
+    });
+
+    expect(await fieldRepository.get()).toEqual(['a', 'b', 'c']);
+  });
+});

package/src/__tests__/fields/set.test.ts

@@ -0,0 +1,37 @@
+import { mockDatabase } from '../';
+import { Database } from '../../database';
+
+describe('set field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should set Set field', async () => {
+    const A = db.collection({
+      name: 'a',
+      fields: [
+        {
+          type: 'set',
+          name: 'set',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    const a = await A.repository.create({});
+
+    a.set('set', ['a', 'b', 'c', 'a']);
+
+    await a.save();
+
+    const setValue = a.get('set');
+    expect(setValue).toEqual(['a', 'b', 'c']);
+  });
+});

package/src/__tests__/filter-match.test.ts

@@ -0,0 +1,52 @@
+import { Database, Model } from '..';
+import { filterMatch } from '../filter-match';
+import { mockDatabase } from './index';
+
+describe('filterMatch', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  test('filter match', async () => {
+    const Post = db.collection({
+      name: 'posts',
+      fields: [{ type: 'string', name: 'title' }],
+    });
+
+    await db.sync();
+
+    const post = await Post.repository.create({
+      values: { title: 't1' },
+    });
+
+    expect(
+      filterMatch(post, {
+        title: 't1',
+      }),
+    ).toBeTruthy();
+
+    expect(
+      filterMatch(post, {
+        $or: [{ title: 't1' }, { title: 't2' }],
+      }),
+    ).toBeTruthy();
+
+    expect(
+      filterMatch(post, {
+        $and: [{ title: 't1' }, { title: 't2' }],
+      }),
+    ).toBeFalsy();
+
+    expect(
+      filterMatch(post, {
+        title: 't2',
+      }),
+    ).toBeFalsy();
+  });
+});