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

package/lib/collection.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import { ModelCtor, ModelOptions, QueryInterfaceDropTableOptions, SyncOptions, Transactionable } from 'sequelize';
+import { ModelOptions, QueryInterfaceDropTableOptions, SyncOptions, Transactionable, ModelStatic } from 'sequelize';
 import { Database } from './database';
 import { Field, FieldOptions } from './fields';
 import { Model } from './model';
@@ -13,9 +13,10 @@ export declare type CollectionSortable = string | boolean | {
 export interface CollectionOptions extends Omit<ModelOptions, 'name' | 'hooks'> {
     name: string;
     tableName?: string;
+    inherits?: string[] | string;
     filterTargetKey?: string;
     fields?: FieldOptions[];
-    model?: string | ModelCtor<Model>;
+    model?: string | ModelStatic<Model>;
     repository?: string | RepositoryType;
     sortable?: CollectionSortable;
     /**
@@ -36,7 +37,7 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     context: CollectionContext;
     isThrough?: boolean;
     fields: Map<string, any>;
-    model: ModelCtor<Model>;
+    model: ModelStatic<Model>;
     repository: Repository<TModelAttributes, TCreationAttributes>;
     get filterTargetKey(): string;
     get name(): string;
@@ -80,5 +81,8 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
         [key: string]: any;
     }): void;
     removeIndex(fields: any): void;
+    refreshIndexes(): void;
     sync(syncOptions?: SyncOptions): Promise<void>;
+    isInherited(): boolean;
+    isParent(): boolean;
 }

package/lib/collection.js

@@ -103,7 +103,12 @@ class Collection extends _events().EventEmitter {
     this.bindFieldEventListener();
     this.modelInit();
     this.db.modelCollection.set(this.model, this);
-    this.setFields(options.fields);
+    this.db.tableNameCollectionMap.set(this.model.tableName, this);
+
+    if (!options.inherits) {
+      this.setFields(options.fields);
+    }
+
     this.setRepository(options.repository);
     this.setSortable(options.sortable);
   }
@@ -184,8 +189,12 @@ class Collection extends _events().EventEmitter {
   }
 
   bindFieldEventListener() {
-    this.on('field.afterAdd', field => field.bind());
-    this.on('field.afterRemove', field => field.unbind());
+    this.on('field.afterAdd', field => {
+      field.bind();
+    });
+    this.on('field.afterRemove', field => {
+      field.unbind();
+    });
   }
 
   forEachField(callback) {
@@ -216,9 +225,45 @@ class Collection extends _events().EventEmitter {
     }, options), _objectSpread(_objectSpread({}, this.context), {}, {
       collection: this
     }));
+    const oldField = this.fields.get(name);
+
+    if (oldField && oldField.options.inherit && field.typeToString() != oldField.typeToString()) {
+      throw new Error(`Field type conflict: cannot set "${name}" on "${this.name}" to ${options.type}, parent "${name}" type is ${oldField.options.type}`);
+    }
+
+    if (this.options.autoGenId !== false && options.primaryKey) {
+      this.model.removeAttribute('id');
+    }
+
     this.removeField(name);
     this.fields.set(name, field);
-    this.emit('field.afterAdd', field);
+    this.emit('field.afterAdd', field); // refresh children models
+
+    if (this.isParent()) {
+      var _iterator = _createForOfIteratorHelper(this.context.database.inheritanceMap.getChildren(this.name, {
+        deep: false
+      })),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          const child = _step.value;
+          const childCollection = this.db.getCollection(child);
+          const existField = childCollection.getField(name);
+
+          if (!existField || existField.options.inherit) {
+            childCollection.setField(name, _objectSpread(_objectSpread({}, options), {}, {
+              inherit: true
+            }));
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+
     return field;
   }
 
@@ -231,12 +276,12 @@ class Collection extends _events().EventEmitter {
       this.resetFields();
     }
 
-    var _iterator = _createForOfIteratorHelper(fields),
-        _step;
+    var _iterator2 = _createForOfIteratorHelper(fields),
+        _step2;
 
     try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        const _ref = _step.value;
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        const _ref = _step2.value;
 
         const name = _ref.name,
               options = _objectWithoutProperties(_ref, _excluded);
@@ -244,27 +289,27 @@ class Collection extends _events().EventEmitter {
         this.addField(name, options);
       }
     } catch (err) {
-      _iterator.e(err);
+      _iterator2.e(err);
     } finally {
-      _iterator.f();
+      _iterator2.f();
     }
   }
 
   resetFields() {
     const fieldNames = this.fields.keys();
 
-    var _iterator2 = _createForOfIteratorHelper(fieldNames),
-        _step2;
+    var _iterator3 = _createForOfIteratorHelper(fieldNames),
+        _step3;
 
     try {
-      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-        const fieldName = _step2.value;
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        const fieldName = _step3.value;
         this.removeField(fieldName);
       }
     } catch (err) {
-      _iterator2.e(err);
+      _iterator3.e(err);
     } finally {
-      _iterator2.f();
+      _iterator3.f();
     }
   }
 
@@ -305,6 +350,29 @@ class Collection extends _events().EventEmitter {
     const bool = this.fields.delete(name);
 
     if (bool) {
+      if (this.isParent()) {
+        var _iterator4 = _createForOfIteratorHelper(this.db.inheritanceMap.getChildren(this.name, {
+          deep: false
+        })),
+            _step4;
+
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            const child = _step4.value;
+            const childCollection = this.db.getCollection(child);
+            const existField = childCollection.getField(name);
+
+            if (existField && existField.options.inherit) {
+              childCollection.removeField(name);
+            }
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      }
+
       this.emit('field.afterRemove', field);
     }
 
@@ -407,12 +475,12 @@ class Collection extends _events().EventEmitter {
       return;
     }
 
-    var _iterator3 = _createForOfIteratorHelper(indexes),
-        _step3;
+    var _iterator5 = _createForOfIteratorHelper(indexes),
+        _step5;
 
     try {
-      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-        const item = _step3.value;
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        const item = _step5.value;
 
         if (_lodash().default.isEqual(item.fields, indexName)) {
           return;
@@ -425,9 +493,9 @@ class Collection extends _events().EventEmitter {
         }
       }
     } catch (err) {
-      _iterator3.e(err);
+      _iterator5.e(err);
     } finally {
-      _iterator3.f();
+      _iterator5.f();
     }
 
     if (!indexItem) {
@@ -446,6 +514,7 @@ class Collection extends _events().EventEmitter {
 
       return item;
     });
+    this.refreshIndexes();
   }
 
   removeIndex(fields) {
@@ -459,6 +528,33 @@ class Collection extends _events().EventEmitter {
     this.model._indexes = indexes.filter(item => {
       return !_lodash().default.isEqual(item.fields, fields);
     });
+    this.refreshIndexes();
+  }
+
+  refreshIndexes() {
+    // @ts-ignore
+    const indexes = this.model._indexes; // @ts-ignore
+
+    this.model._indexes = indexes.filter(item => {
+      var _iterator6 = _createForOfIteratorHelper(item.fields),
+          _step6;
+
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          const field = _step6.value;
+
+          if (!this.model.rawAttributes[field]) {
+            return false;
+          }
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+
+      return true;
+    });
   }
 
   sync(syncOptions) {
@@ -492,6 +588,14 @@ class Collection extends _events().EventEmitter {
     })();
   }
 
+  isInherited() {
+    return false;
+  }
+
+  isParent() {
+    return this.context.database.inheritanceMap.isParentNode(this.name);
+  }
+
 }
 
 exports.Collection = Collection;

package/lib/database.d.ts

@@ -2,24 +2,26 @@
 import { AsyncEmitter } from '@nocobase/utils';
 import merge from 'deepmerge';
 import { EventEmitter } from 'events';
-import { ModelCtor, Options, QueryInterfaceDropAllTablesOptions, QueryOptions, Sequelize, SyncOptions, Transactionable } from 'sequelize';
+import { ModelStatic, Options, QueryInterfaceDropAllTablesOptions, QueryOptions, Sequelize, SyncOptions, Transactionable } from 'sequelize';
 import { Umzug } from 'umzug';
 import { Collection, CollectionOptions, RepositoryType } from './collection';
 import { ImportFileExtension } from './collection-importer';
+import ReferencesMap from './features/ReferencesMap';
+import { ArrayFieldRepository } from './field-repository/array-field-repository';
 import * as FieldTypes from './fields';
 import { Field, FieldContext, RelationField } from './fields';
+import InheritanceMap from './inherited-map';
 import { MigrationItem, Migrations } from './migration';
 import { Model } from './model';
 import { ModelHook } from './model-hook';
 import { RelationRepository } from './relation-repository/relation-repository';
 import { Repository } from './repository';
 import { AfterDefineCollectionListener, BeforeDefineCollectionListener, CreateListener, CreateWithAssociationsListener, DatabaseAfterDefineCollectionEventType, DatabaseAfterRemoveCollectionEventType, DatabaseBeforeDefineCollectionEventType, DatabaseBeforeRemoveCollectionEventType, DestroyListener, EventType, ModelCreateEventTypes, ModelCreateWithAssociationsEventTypes, ModelDestroyEventTypes, ModelSaveEventTypes, ModelSaveWithAssociationsEventTypes, ModelUpdateEventTypes, ModelUpdateWithAssociationsEventTypes, ModelValidateEventTypes, RemoveCollectionListener, SaveListener, SaveWithAssociationsListener, SyncListener, UpdateListener, UpdateWithAssociationsListener, ValidateListener } from './types';
-import ReferencesMap from './features/ReferencesMap';
 export interface MergeOptions extends merge.Options {
 }
 export interface PendingOptions {
     field: RelationField;
-    model: ModelCtor<Model>;
+    model: ModelStatic<Model>;
 }
 interface MapOf<T> {
     [key: string]: T;
@@ -27,6 +29,7 @@ interface MapOf<T> {
 export interface IDatabaseOptions extends Options {
     tablePrefix?: string;
     migrator?: any;
+    usingBigIntForId?: boolean;
 }
 export declare type DatabaseOptions = IDatabaseOptions;
 interface RegisterOperatorsContext {
@@ -56,13 +59,15 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     migrations: Migrations;
     fieldTypes: Map<any, any>;
     options: IDatabaseOptions;
-    models: Map<string, ModelCtor<Model<any, any>>>;
+    models: Map<string, ModelStatic<Model<any, any>>>;
     repositories: Map<string, typeof Repository>;
     operators: Map<any, any>;
     collections: Map<string, Collection<any, any>>;
     pendingFields: Map<string, FieldTypes.RelationField[]>;
-    modelCollection: Map<ModelCtor<any>, Collection<any, any>>;
+    modelCollection: Map<ModelStatic<any>, Collection<any, any>>;
+    tableNameCollectionMap: Map<string, Collection<any, any>>;
     referenceMap: ReferencesMap;
+    inheritanceMap: InheritanceMap;
     modelHook: ModelHook;
     version: DatabaseVersion;
     delayCollectionExtend: Map<string, {
@@ -87,13 +92,14 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     getCollection(name: string): Collection;
     hasCollection(name: string): boolean;
     removeCollection(name: string): Collection<any, any>;
-    getModel<M extends Model>(name: string): ModelCtor<M>;
+    getModel<M extends Model>(name: string): ModelStatic<M>;
     getRepository<R extends Repository>(name: string): R;
     getRepository<R extends RelationRepository>(name: string, relationId: string | number): R;
+    getRepository<R extends ArrayFieldRepository>(name: string, relationId: string | number): R;
     addPendingField(field: RelationField): void;
     removePendingField(field: RelationField): void;
     registerFieldTypes(fieldTypes: MapOf<typeof Field>): void;
-    registerModels(models: MapOf<ModelCtor<any>>): void;
+    registerModels(models: MapOf<ModelStatic<any>>): void;
     registerRepositories(repositories: MapOf<RepositoryType>): void;
     initOperators(): void;
     registerOperators(operators: MapOf<OperatorFunc>): void;

package/lib/database.js

@@ -90,18 +90,22 @@ var _collection = require("./collection");
 
 var _collectionImporter = require("./collection-importer");
 
+var _ReferencesMap = _interopRequireDefault(require("./features/ReferencesMap"));
+
+var _referentialIntegrityCheck = require("./features/referential-integrity-check");
+
 var FieldTypes = _interopRequireWildcard(require("./fields"));
 
+var _inheritedCollection = require("./inherited-collection");
+
+var _inheritedMap = _interopRequireDefault(require("./inherited-map"));
+
 var _migration = require("./migration");
 
 var _modelHook = require("./model-hook");
 
 var _operators = _interopRequireDefault(require("./operators"));
 
-var _referentialIntegrityCheck = require("./features/referential-integrity-check");
-
-var _ReferencesMap = _interopRequireDefault(require("./features/ReferencesMap"));
-
 const _excluded = ["drop"],
       _excluded2 = ["retry"];
 
@@ -196,8 +200,7 @@ class DatabaseVersion {
 
 class Database extends _events().EventEmitter {
   constructor(options) {
-    super(); // this.setMaxListeners(100);
-
+    super();
     this.sequelize = void 0;
     this.migrator = void 0;
     this.migrations = void 0;
@@ -209,7 +212,9 @@ class Database extends _events().EventEmitter {
     this.collections = new Map();
     this.pendingFields = new Map();
     this.modelCollection = new Map();
+    this.tableNameCollectionMap = new Map();
     this.referenceMap = new _ReferencesMap.default();
+    this.inheritanceMap = new _inheritedMap.default();
     this.modelHook = void 0;
     this.version = void 0;
     this.delayCollectionExtend = new Map();
@@ -236,6 +241,11 @@ class Database extends _events().EventEmitter {
       opts.timezone = '+00:00';
     }
 
+    if (options.dialect === 'postgres') {
+      // https://github.com/sequelize/sequelize/issues/1774
+      require('pg').defaults.parseInt8 = true;
+    }
+
     this.sequelize = new (_sequelize().Sequelize)(opts);
     this.options = opts;
     this.collections = new Map();
@@ -332,6 +342,19 @@ class Database extends _events().EventEmitter {
         return _ref3.apply(this, arguments);
       };
     }());
+    this.on('afterRemoveCollection', collection => {
+      this.inheritanceMap.removeNode(collection.name);
+    });
+    this.on('afterDefine', model => {
+      if (_lodash().default.get(this.options, 'usingBigIntForId', true)) {
+        const idAttribute = model.rawAttributes['id'];
+
+        if (idAttribute && idAttribute.primaryKey) {
+          model.rawAttributes['id'].type = _sequelize().DataTypes.BIGINT;
+          model.refreshAttributes();
+        }
+      }
+    });
   }
 
   addMigration(item) {
@@ -382,7 +405,14 @@ class Database extends _events().EventEmitter {
 
   collection(options) {
     this.emit('beforeDefineCollection', options);
-    const collection = new _collection.Collection(options, {
+
+    const hasValidInheritsOptions = (() => {
+      return options.inherits && _lodash().default.castArray(options.inherits).length > 0;
+    })();
+
+    const collection = hasValidInheritsOptions ? new _inheritedCollection.InheritedCollection(options, {
+      database: this
+    }) : new _collection.Collection(options, {
       database: this
     });
     this.collections.set(collection.name, collection);
@@ -410,6 +440,7 @@ class Database extends _events().EventEmitter {
   removeCollection(name) {
     const collection = this.collections.get(name);
     this.emit('beforeRemoveCollection', collection);
+    collection.resetFields();
     const result = this.collections.delete(name);
     this.sequelize.modelManager.removeModel(collection.model);
 
@@ -593,7 +624,7 @@ class Database extends _events().EventEmitter {
             return true;
           } catch (error) {
             if (count >= retry) {
-              throw error;
+              throw new Error('Connection failed, please check your database connection credentials and try again.');
             }
 
             console.log('reconnecting...', count);

package/lib/decorators/must-have-filter-decorator.js

@@ -11,6 +11,10 @@ const mustHaveFilter = () => (target, propertyKey, descriptor) => {
   descriptor.value = function () {
     const options = arguments[0];
 
+    if (Array.isArray(options.values)) {
+      return oldValue.apply(this, arguments);
+    }
+
     if (!(options === null || options === void 0 ? void 0 : options.filter) && !(options === null || options === void 0 ? void 0 : options.filterByTk) && !(options === null || options === void 0 ? void 0 : options.forceUpdate)) {
       throw new Error(`must provide filter or filterByTk for ${propertyKey} call, or set forceUpdate to true`);
     }

package/lib/decorators/transaction-decorator.js

@@ -67,6 +67,7 @@ function transactionWrapperBuilder(transactionGenerator) {
             yield transaction.commit();
             return results;
           } catch (err) {
+            console.error(err);
             yield transaction.rollback();
             throw err;
           }

package/lib/features/ReferencesMap.js

@@ -11,21 +11,26 @@ class ReferencesMap {
   }
 
   addReference(reference) {
+    if (!reference.onDelete) {
+      reference.onDelete = 'SET NULL';
+    }
+
     const existReference = this.existReference(reference);
 
-    if (existReference) {
-      if (reference.onDelete && existReference.onDelete !== reference.onDelete) {
+    if (existReference && existReference.onDelete !== reference.onDelete) {
+      if (reference.onDelete === 'SET NULL') {
+        // using existing reference
+        return;
+      } else if (existReference.onDelete === 'SET NULL') {
+        existReference.onDelete = reference.onDelete;
+      } else {
         throw new Error(`On Delete Conflict, exist reference ${JSON.stringify(existReference)}, new reference ${JSON.stringify(reference)}`);
       }
-
-      return;
     }
 
-    if (!reference.onDelete) {
-      reference.onDelete = 'SET NULL';
+    if (!existReference) {
+      this.map.set(reference.targetCollectionName, [...(this.map.get(reference.targetCollectionName) || []), reference]);
     }
-
-    this.map.set(reference.targetCollectionName, [...(this.map.get(reference.targetCollectionName) || []), reference]);
   }
 
   getReferences(collectionName) {
@@ -50,7 +55,7 @@ class ReferencesMap {
       return;
     }
 
-    const keys = Object.keys(reference);
+    const keys = ['sourceCollectionName', 'sourceField', 'targetField', 'targetCollectionName'];
     this.map.set(reference.targetCollectionName, references.filter(ref => !keys.every(key => ref[key] === reference[key])));
   }
 

package/lib/field-repository/array-field-repository.d.ts

@@ -0,0 +1,28 @@
+import { Transactionable } from 'sequelize/types';
+import { Collection } from '../collection';
+export declare class ArrayFieldRepository {
+    protected collection: Collection;
+    protected fieldName: string;
+    protected targetValue: string | number;
+    constructor(collection: Collection, fieldName: string, targetValue: string | number);
+    get(options?: Transactionable): Promise<any>;
+    find(options?: Transactionable): Promise<any>;
+    set(options: Transactionable & {
+        values: Array<string | number> | string | number;
+        hooks?: boolean;
+    }): Promise<void>;
+    protected emitAfterSave(instance: any, options: any): Promise<void>;
+    toggle(options: Transactionable & {
+        value: string | number;
+        hooks?: boolean;
+    }): Promise<void>;
+    add(options: Transactionable & {
+        values: Array<string | number> | string | number;
+        hooks?: boolean;
+    }): Promise<void>;
+    remove(options: Transactionable & {
+        values: Array<string | number> | string | number;
+        hooks?: boolean;
+    }): Promise<void>;
+    protected getInstance(options: Transactionable): Promise<any>;
+}