@nocobase/database 0.7.7-alpha.1 → 0.8.0-alpha.5

package/src/__tests__/relation-repository/hasone-repository.test.ts

@@ -1,7 +1,7 @@
-import { mockDatabase } from '../index';
-import { HasOneRepository } from '../../relation-repository/hasone-repository';
-import Database from '../../database';
 import { Collection } from '../../collection';
+import Database from '../../database';
+import { HasOneRepository } from '../../relation-repository/hasone-repository';
+import { mockDatabase } from '../index';
 
 describe('has one repository', () => {
   let db: Database;

package/src/__tests__/repository/find.test.ts

@@ -163,6 +163,16 @@ describe('repository find', () => {
       expect(users[1]).toEqual(2);
     });
 
+    test('find with empty or', async () => {
+      const usersCount = await User.repository.count({
+        filter: {
+          $or: [],
+        },
+      });
+
+      expect(usersCount).toEqual(await User.repository.count());
+    });
+
     test('find with fields', async () => {
       let user = await User.repository.findOne({
         fields: ['name'],

package/src/collection.ts

@@ -65,7 +65,7 @@ export class Collection<
     return this.context.database;
   }
 
-  constructor(options: CollectionOptions, context?: CollectionContext) {
+  constructor(options: CollectionOptions, context: CollectionContext) {
     super();
     this.checkOptions(options);
 
@@ -74,6 +74,8 @@ export class Collection<
 
     this.bindFieldEventListener();
     this.modelInit();
+    this.db.modelCollection.set(this.model, this);
+
     this.setFields(options.fields);
     this.setRepository(options.repository);
     this.setSortable(options.sortable);

package/src/database.ts

@@ -1,4 +1,4 @@
-import { applyMixins, AsyncEmitter } from '@nocobase/utils';
+import { applyMixins, AsyncEmitter, requireModule } from '@nocobase/utils';
 import merge from 'deepmerge';
 import { EventEmitter } from 'events';
 import glob from 'glob';
@@ -14,7 +14,7 @@ import {
   Sequelize,
   SyncOptions,
   Transactionable,
-  Utils
+  Utils,
 } from 'sequelize';
 import { SequelizeStorage, Umzug } from 'umzug';
 import { Collection, CollectionOptions, RepositoryType } from './collection';
@@ -27,6 +27,35 @@ import { ModelHook } from './model-hook';
 import extendOperators from './operators';
 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 { referentialIntegrityCheck } from './features/referential-integrity-check';
+import ReferencesMap from './features/ReferencesMap';
 
 export interface MergeOptions extends merge.Options {}
 
@@ -119,6 +148,7 @@ export class Database extends EventEmitter implements AsyncEmitter {
   collections = new Map<string, Collection>();
   pendingFields = new Map<string, RelationField[]>();
   modelCollection = new Map<ModelCtor<any>, Collection>();
+  referenceMap = new ReferencesMap();
 
   modelHook: ModelHook;
   version: DatabaseVersion;
@@ -128,6 +158,8 @@ export class Database extends EventEmitter implements AsyncEmitter {
   constructor(options: DatabaseOptions) {
     super();
 
+    // this.setMaxListeners(100);
+
     this.version = new DatabaseVersion(this);
 
     const opts = {
@@ -206,6 +238,10 @@ export class Database extends EventEmitter implements AsyncEmitter {
       }
     });
 
+    this.initListener();
+  }
+
+  initListener() {
     this.on('afterCreate', async (instance) => {
       instance?.toChangedWithAssociations?.();
     });
@@ -213,6 +249,14 @@ export class Database extends EventEmitter implements AsyncEmitter {
     this.on('afterUpdate', async (instance) => {
       instance?.toChangedWithAssociations?.();
     });
+
+    this.on('beforeDestroy', async (instance, options) => {
+      await referentialIntegrityCheck({
+        db: this,
+        referencedInstance: instance,
+        transaction: options.transaction,
+      });
+    });
   }
 
   addMigration(item: MigrationItem) {
@@ -230,7 +274,7 @@ export class Database extends EventEmitter implements AsyncEmitter {
       filename = filename.substring(0, filename.lastIndexOf('.')) || filename;
       this.migrations.add({
         name: namespace ? `${namespace}/${filename}` : filename,
-        migration: this.requireModule(file),
+        migration: requireModule(file),
         context,
       });
     }
@@ -240,16 +284,6 @@ export class Database extends EventEmitter implements AsyncEmitter {
     return dialect.includes(this.sequelize.getDialect());
   }
 
-  private requireModule(module: any) {
-    if (typeof module === 'string') {
-      module = require(module);
-    }
-    if (typeof module !== 'object') {
-      return module;
-    }
-    return module.__esModule ? module.default : module;
-  }
-
   /**
    * Add collection to database
    * @param options
@@ -264,7 +298,6 @@ export class Database extends EventEmitter implements AsyncEmitter {
     });
 
     this.collections.set(collection.name, collection);
-    this.modelCollection.set(collection.model, collection);
 
     this.emit('afterDefineCollection', collection);
 
@@ -466,7 +499,23 @@ export class Database extends EventEmitter implements AsyncEmitter {
     return this.sequelize.close();
   }
 
-  on(event: string | symbol, listener): this {
+  on(event: EventType, listener: any): this;
+  on(event: ModelValidateEventTypes, listener: SyncListener): this;
+  on(event: ModelValidateEventTypes, listener: ValidateListener): this;
+  on(event: ModelCreateEventTypes, listener: CreateListener): this;
+  on(event: ModelUpdateEventTypes, listener: UpdateListener): this;
+  on(event: ModelSaveEventTypes, listener: SaveListener): this;
+  on(event: ModelDestroyEventTypes, listener: DestroyListener): this;
+  on(event: ModelCreateWithAssociationsEventTypes, listener: CreateWithAssociationsListener): this;
+  on(event: ModelUpdateWithAssociationsEventTypes, listener: UpdateWithAssociationsListener): this;
+  on(event: ModelSaveWithAssociationsEventTypes, listener: SaveWithAssociationsListener): this;
+  on(event: DatabaseBeforeDefineCollectionEventType, listener: BeforeDefineCollectionListener): this;
+  on(event: DatabaseAfterDefineCollectionEventType, listener: AfterDefineCollectionListener): this;
+  on(
+    event: DatabaseBeforeRemoveCollectionEventType | DatabaseAfterRemoveCollectionEventType,
+    listener: RemoveCollectionListener,
+  ): this;
+  on(event: EventType, listener: any): this {
     // NOTE: to match if event is a sequelize or model type
     const type = this.modelHook.match(event);
 

package/src/features/ReferencesMap.ts

@@ -0,0 +1,64 @@
+export interface Reference {
+  sourceCollectionName: string;
+  sourceField: string;
+  targetField: string;
+  targetCollectionName: string;
+  onDelete: string;
+}
+
+class ReferencesMap {
+  protected map: Map<string, Reference[]> = new Map();
+
+  addReference(reference: Reference) {
+    const existReference = this.existReference(reference);
+
+    if (existReference) {
+      if (reference.onDelete && existReference.onDelete !== reference.onDelete) {
+        throw new Error(
+          `On Delete Conflict, exist reference ${JSON.stringify(existReference)}, new reference ${JSON.stringify(
+            reference,
+          )}`,
+        );
+      }
+
+      return;
+    }
+
+    if (!reference.onDelete) {
+      reference.onDelete = 'SET NULL';
+    }
+
+    this.map.set(reference.targetCollectionName, [...(this.map.get(reference.targetCollectionName) || []), reference]);
+  }
+
+  getReferences(collectionName) {
+    return this.map.get(collectionName);
+  }
+
+  existReference(reference: Reference) {
+    const references = this.map.get(reference.targetCollectionName);
+
+    if (!references) {
+      return null;
+    }
+
+    const keys = Object.keys(reference).filter((k) => k !== 'onDelete');
+
+    return references.find((ref) => keys.every((key) => ref[key] === reference[key]));
+  }
+
+  removeReference(reference: Reference) {
+    const references = this.map.get(reference.targetCollectionName);
+    if (!references) {
+      return;
+    }
+    const keys = Object.keys(reference);
+
+    this.map.set(
+      reference.targetCollectionName,
+      references.filter((ref) => !keys.every((key) => ref[key] === reference[key])),
+    );
+  }
+}
+
+export default ReferencesMap;

package/src/features/referential-integrity-check.ts

@@ -0,0 +1,61 @@
+import Database from '../database';
+import { Model, Transactionable } from 'sequelize';
+
+interface ReferentialIntegrityCheckOptions extends Transactionable {
+  db: Database;
+  referencedInstance: Model;
+}
+
+export async function referentialIntegrityCheck(options: ReferentialIntegrityCheckOptions) {
+  const { referencedInstance, db, transaction } = options;
+
+  // @ts-ignore
+  const collection = db.modelCollection.get(referencedInstance.constructor);
+
+  const collectionName = collection.name;
+  const references = db.referenceMap.getReferences(collectionName);
+
+  if (!references) {
+    return;
+  }
+
+  for (const reference of references) {
+    const { sourceCollectionName, sourceField, targetField, onDelete } = reference;
+    const sourceCollection = db.collections.get(sourceCollectionName);
+    const sourceRepository = sourceCollection.repository;
+
+    const filter = {
+      [sourceField]: referencedInstance[targetField],
+    };
+    const referencingExists = await sourceRepository.count({
+      filter,
+      transaction,
+    });
+
+    if (!referencingExists) {
+      continue;
+    }
+
+    if (onDelete === 'RESTRICT') {
+      throw new Error('RESTRICT');
+    }
+
+    if (onDelete === 'CASCADE') {
+      await sourceRepository.destroy({
+        filter: filter,
+        transaction,
+      });
+    }
+
+    if (onDelete === 'SET NULL') {
+      await sourceRepository.update({
+        filter,
+        values: {
+          [sourceField]: null,
+        },
+        hooks: false,
+        transaction,
+      });
+    }
+  }
+}

package/src/fields/belongs-to-field.ts

@@ -2,6 +2,7 @@ import { omit } from 'lodash';
 import { BelongsToOptions as SequelizeBelongsToOptions, Utils } from 'sequelize';
 import { checkIdentifier } from '../utils';
 import { BaseRelationFieldOptions, RelationField } from './relation-field';
+import { Reference } from '../features/ReferencesMap';
 
 export class BelongsToField extends RelationField {
   static type = 'belongsTo';
@@ -11,6 +12,18 @@ export class BelongsToField extends RelationField {
     return target || Utils.pluralize(name);
   }
 
+  reference(association): Reference {
+    const targetKey = association.targetKey;
+
+    return {
+      sourceCollectionName: this.database.modelCollection.get(association.source).name,
+      sourceField: association.foreignKey,
+      targetField: targetKey,
+      targetCollectionName: this.database.modelCollection.get(association.target).name,
+      onDelete: this.options.onDelete,
+    };
+  }
+
   bind() {
     const { database, collection } = this.context;
     const Target = this.TargetModel;
@@ -30,7 +43,7 @@ export class BelongsToField extends RelationField {
     const association = collection.model.belongsTo(Target, {
       as: this.name,
       constraints: false,
-      ...omit(this.options, ['name', 'type', 'target']),
+      ...omit(this.options, ['name', 'type', 'target', 'onDelete']),
     });
 
     // inverse relation
@@ -56,6 +69,9 @@ export class BelongsToField extends RelationField {
     }
 
     this.collection.addIndex([this.options.foreignKey]);
+
+    this.database.referenceMap.addReference(this.reference(association));
+
     return true;
   }
 
@@ -73,6 +89,10 @@ export class BelongsToField extends RelationField {
     if (!field1 && !field2) {
       collection.model.removeAttribute(foreignKey);
     }
+
+    const association = collection.model.associations[this.name];
+    this.database.referenceMap.removeReference(this.reference(association));
+
     // 删掉 model 的关联字段
     delete collection.model.associations[this.name];
     // @ts-ignore

package/src/fields/belongs-to-many-field.ts

@@ -17,6 +17,10 @@ export class BelongsToManyField extends RelationField {
     );
   }
 
+  get otherKey() {
+    return this.options.otherKey;
+  }
+
   bind() {
     const { database, collection } = this.context;
     const Target = this.TargetModel;
@@ -34,6 +38,7 @@ export class BelongsToManyField extends RelationField {
     } else {
       Through = database.collection({
         name: through,
+        // timestamps: false,
       });
 
       Object.defineProperty(Through.model, 'isThrough', { value: true });
@@ -80,6 +85,7 @@ export class BelongsToManyField extends RelationField {
 
   unbind() {
     const { database, collection } = this.context;
+    const Through = database.getCollection(this.through);
     // 如果关系字段还没建立就删除了，也同步删除待建立关联的关系字段
     database.removePendingField(this);
     // 删掉 model 的关联字段

package/src/fields/context-field.ts

@@ -9,14 +9,12 @@ export class ContextField extends Field {
     return DataTypes[type.toUpperCase()] || DataTypes.STRING;
   }
 
-  init() {
+  listener = async (model: Model, options) => {
     const { name, dataIndex } = this.options;
-    this.listener = async (model: Model, options) => {
-      const { context } = options;
-      model.set(name, lodash.get(context, dataIndex));
-      model.changed(name, true);
-    };
-  }
+    const { context } = options;
+    model.set(name, lodash.get(context, dataIndex));
+    model.changed(name, true);
+  };
 
   bind() {
     super.bind();

package/src/fields/field.ts

@@ -5,11 +5,11 @@ import {
   ModelIndexesOptions,
   QueryInterfaceOptions,
   SyncOptions,
-  Transactionable,
+  Transactionable
 } from 'sequelize';
 import { Collection } from '../collection';
 import { Database } from '../database';
-import { checkIdentifier } from '../utils';
+import { ModelEventTypes } from '../types';
 
 export interface FieldContext {
   database: Database;
@@ -68,7 +68,7 @@ export abstract class Field {
     // code
   }
 
-  on(eventName: string, listener: (...args: any[]) => void) {
+  on(eventName: ModelEventTypes, listener: (...args: any[]) => void) {
     this.database.on(`${this.collection.name}.${eventName}`, listener);
     return this;
   }
@@ -83,6 +83,7 @@ export abstract class Field {
   }
 
   remove() {
+    this.collection.removeIndex([this.name]);
     return this.collection.removeField(this.name);
   }
 

package/src/fields/has-many-field.ts

@@ -5,11 +5,12 @@ import {
   ForeignKeyOptions,
   HasManyOptions,
   HasManyOptions as SequelizeHasManyOptions,
-  Utils
+  Utils,
 } from 'sequelize';
 import { Collection } from '../collection';
 import { checkIdentifier } from '../utils';
 import { MultipleRelationFieldOptions, RelationField } from './relation-field';
+import { Reference } from '../features/ReferencesMap';
 
 export interface HasManyFieldOptions extends HasManyOptions {
   /**
@@ -81,6 +82,18 @@ export class HasManyField extends RelationField {
     return Utils.camelize([model.options.name.singular, this.sourceKey || model.primaryKeyAttribute].join('_'));
   }
 
+  reference(association): Reference {
+    const sourceKey = association.sourceKey;
+
+    return {
+      sourceCollectionName: this.database.modelCollection.get(association.target).name,
+      sourceField: association.foreignKey,
+      targetField: sourceKey,
+      targetCollectionName: this.database.modelCollection.get(association.source).name,
+      onDelete: this.options.onDelete,
+    };
+  }
+
   bind() {
     const { database, collection } = this.context;
     const Target = this.TargetModel;
@@ -95,7 +108,7 @@ export class HasManyField extends RelationField {
 
     const association = collection.model.hasMany(Target, {
       constraints: false,
-      ...omit(this.options, ['name', 'type', 'target']),
+      ...omit(this.options, ['name', 'type', 'target', 'onDelete']),
       as: this.name,
       foreignKey: this.foreignKey,
     });
@@ -130,6 +143,9 @@ export class HasManyField extends RelationField {
     if (tcoll) {
       tcoll.addIndex([this.options.foreignKey]);
     }
+
+    this.database.referenceMap.addReference(this.reference(association));
+
     return true;
   }
 
@@ -149,6 +165,13 @@ export class HasManyField extends RelationField {
     if (!field) {
       tcoll.model.removeAttribute(foreignKey);
     }
+
+    const association = collection.model.associations[this.name];
+
+    if (association) {
+      this.database.referenceMap.removeReference(this.reference(association));
+    }
+
     // 删掉 model 的关联字段
     delete collection.model.associations[this.name];
     // @ts-ignore

package/src/fields/has-one-field.ts

@@ -5,11 +5,12 @@ import {
   ForeignKeyOptions,
   HasOneOptions,
   HasOneOptions as SequelizeHasOneOptions,
-  Utils
+  Utils,
 } from 'sequelize';
 import { Collection } from '../collection';
 import { checkIdentifier } from '../utils';
 import { BaseRelationFieldOptions, RelationField } from './relation-field';
+import { Reference } from '../features/ReferencesMap';
 
 export interface HasOneFieldOptions extends HasOneOptions {
   /**
@@ -86,9 +87,22 @@ export class HasOneField extends RelationField {
     return Utils.camelize([model.options.name.singular, model.primaryKeyAttribute].join('_'));
   }
 
+  reference(association): Reference {
+    const sourceKey = association.sourceKey;
+
+    return {
+      sourceCollectionName: this.database.modelCollection.get(association.target).name,
+      sourceField: association.foreignKey,
+      targetField: sourceKey,
+      targetCollectionName: this.database.modelCollection.get(association.source).name,
+      onDelete: this.options.onDelete,
+    };
+  }
+
   bind() {
     const { database, collection } = this.context;
     const Target = this.TargetModel;
+
     if (!Target) {
       database.addPendingField(this);
       return false;
@@ -96,7 +110,7 @@ export class HasOneField extends RelationField {
 
     const association = collection.model.hasOne(Target, {
       constraints: false,
-      ...omit(this.options, ['name', 'type', 'target']),
+      ...omit(this.options, ['name', 'type', 'target', 'onDelete']),
       as: this.name,
       foreignKey: this.foreignKey,
     });
@@ -129,6 +143,8 @@ export class HasOneField extends RelationField {
     if (tcoll) {
       tcoll.addIndex([this.options.foreignKey]);
     }
+
+    this.database.referenceMap.addReference(this.reference(association));
     return true;
   }
 
@@ -148,6 +164,10 @@ export class HasOneField extends RelationField {
     if (!field) {
       tcoll.model.removeAttribute(foreignKey);
     }
+
+    const association = collection.model.associations[this.name];
+    this.database.referenceMap.removeReference(this.reference(association));
+
     // 删掉 model 的关联字段
     delete collection.model.associations[this.name];
     // @ts-ignore

package/src/filter-parser.ts

@@ -78,7 +78,6 @@ export default class FilterParser {
 
     const include = {};
     const where = {};
-    const filter2 = lodash.cloneDeep(flattenedFilter);
 
     let skipPrefix = null;
     const associations = model.associations;
@@ -91,6 +90,11 @@ export default class FilterParser {
         continue;
       }
 
+      // skip empty logic operator value
+      if ((key == '$or' || key == '$and') && Array.isArray(value) && value.length == 0) {
+        continue;
+      }
+
       debug('handle filter key "%s: "%s"', key, value);
       let keys = key.split('.');
 

package/src/model.ts

@@ -23,6 +23,7 @@ export class Model<TModelAttributes extends {} = any, TCreationAttributes extend
   public static database: Database;
   public static collection: Collection;
 
+  [key: string]: any;
   protected _changedWithAssociations = new Set();
   protected _previousDataValuesWithAssociations = {};
 

package/src/options-parser.ts

@@ -70,6 +70,7 @@ export class OptionsParser {
     if (typeof sort === 'string') {
       sort = sort.split(',');
     }
+
     const orderParams = [];
     for (const sortKey of sort) {
       let direction = sortKey.startsWith('-') ? 'DESC' : 'ASC';
@@ -191,8 +192,9 @@ export class OptionsParser {
 
     /**
      * set include params
-     * @param includeRoot
-     * @param appends
+     * @param model
+     * @param queryParams
+     * @param append
      */
     const setInclude = (model: ModelCtor<any>, queryParams: any, append: string) => {
       const appendFields = append.split('.');

package/src/relation-repository/belongs-to-many-repository.ts

@@ -1,9 +1,9 @@
 import lodash from 'lodash';
 import { BelongsToMany, Op, Transaction } from 'sequelize';
 import { Model } from '../model';
-import { CreateOptions, DestroyOptions, FindOptions, TargetKey, UpdateOptions } from '../repository';
+import { CreateOptions, DestroyOptions, FindOneOptions, FindOptions, TargetKey, UpdateOptions } from '../repository';
 import { updateThroughTableValue } from '../update-associations';
-import { FindAndCountOptions, FindOneOptions, MultipleRelationRepository } from './multiple-relation-repository';
+import { FindAndCountOptions, MultipleRelationRepository } from './multiple-relation-repository';
 import { transaction } from './relation-repository';
 import { AssociatedOptions, PrimaryKeyWithThroughValues } from './types';
 
@@ -14,7 +14,7 @@ interface IBelongsToManyRepository<M extends Model> {
   findAndCount(options?: FindAndCountOptions): Promise<[M[], number]>;
   findOne(options?: FindOneOptions): Promise<M>;
   // 新增并关联，存在中间表数据
-  create(options?: CreateBelongsToManyOptions): Promise<M>;
+  create(options?: CreateOptions): Promise<M>;
   // 更新，存在中间表数据
   update(options?: UpdateOptions): Promise<M>;
   // 删除

package/src/relation-repository/hasmany-repository.ts

@@ -1,13 +1,16 @@
 import { omit } from 'lodash';
 import { HasMany, Op } from 'sequelize';
 import { Model } from '../model';
-import { CreateOptions, DestroyOptions, FindOptions, TargetKey, TK, UpdateOptions } from '../repository';
 import {
-  AssociatedOptions,
-  FindAndCountOptions,
+  CreateOptions,
+  DestroyOptions,
   FindOneOptions,
-  MultipleRelationRepository
-} from './multiple-relation-repository';
+  FindOptions,
+  TargetKey,
+  TK,
+  UpdateOptions,
+} from '../repository';
+import { AssociatedOptions, FindAndCountOptions, MultipleRelationRepository } from './multiple-relation-repository';
 import { transaction } from './relation-repository';
 
 interface IHasManyRepository<M extends Model> {