@nocobase/database 0.7.6-alpha.2 → 0.8.0-alpha.4

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> {

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

@@ -2,12 +2,10 @@ import { Model } from '../model';
 import { CreateOptions } from '../repository';
 import { SingleRelationFindOption, SingleRelationRepository } from './single-relation-repository';
 
-interface HasOneFindOptions extends SingleRelationFindOption {}
-
 interface IHasOneRepository<M extends Model> {
   // 不需要 findOne，find 就是 findOne
-  find(options?: HasOneFindOptions): Promise<M>;
-  findOne(options?: HasOneFindOptions): Promise<M>;
+  find(options?: SingleRelationFindOption): Promise<M>;
+  findOne(options?: SingleRelationFindOption): Promise<M>;
   // 新增并关联，如果存在关联，解除之后，与新数据建立关联
   create(options?: CreateOptions): Promise<M>;
   // 更新

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

@@ -5,7 +5,7 @@ import {
   CountOptions,
   DestroyOptions,
   Filter,
-  FilterByTk,
+  FindOneOptions,
   FindOptions,
   TargetKey,
   TK,
@@ -16,9 +16,7 @@ import { UpdateGuard } from '../update-guard';
 import { RelationRepository, transaction } from './relation-repository';
 import { handleAppendsQuery } from '../utils';
 
-export interface FindAndCountOptions extends CommonFindOptions {}
-
-export interface FindOneOptions extends CommonFindOptions, FilterByTk {}
+export type FindAndCountOptions = CommonFindOptions;
 
 export interface AssociatedOptions extends Transactionable {
   tk?: TK;
@@ -88,6 +86,7 @@ export abstract class MultipleRelationRepository extends RelationRepository {
 
   async findAndCount(options?: FindAndCountOptions): Promise<[any[], number]> {
     const transaction = await this.getTransaction(options, false);
+
     return [
       await this.find({
         ...options,

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

@@ -2,12 +2,12 @@ import lodash from 'lodash';
 import { Association, BelongsTo, BelongsToMany, HasMany, HasOne, ModelCtor, Transaction } from 'sequelize';
 import { Collection } from '../collection';
 import Database from '../database';
+import { transactionWrapperBuilder } from '../decorators/transaction-decorator';
 import { RelationField } from '../fields/relation-field';
 import FilterParser from '../filter-parser';
 import { Model } from '../model';
 import { OptionsParser } from '../options-parser';
 import { CreateOptions, Filter, FindOptions } from '../repository';
-import { transactionWrapperBuilder } from '../decorators/transaction-decorator';
 import { updateAssociations } from '../update-associations';
 import { UpdateGuard } from '../update-guard';
 

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

@@ -44,7 +44,7 @@ export abstract class SingleRelationRepository extends RelationRepository {
     });
   }
 
-  async find(options?: SingleRelationFindOption): Promise<Model<any>> {
+  async find(options?: SingleRelationFindOption): Promise<Model<any> | null> {
     const transaction = await this.getTransaction(options);
 
     const findOptions = this.buildQueryOptions({

package/src/repository.ts

@@ -2,6 +2,7 @@ import lodash, { omit } from 'lodash';
 import {
   Association,
   BulkCreateOptions,
+  CountOptions as SequelizeCountOptions,
   CreateOptions as SequelizeCreateOptions,
   DestroyOptions as SequelizeDestroyOptions,
   FindAndCountOptions as SequelizeAndCountOptions,
@@ -9,8 +10,9 @@ import {
   ModelCtor,
   Op,
   Transactionable,
-  UpdateOptions as SequelizeUpdateOptions
+  UpdateOptions as SequelizeUpdateOptions,
 } from 'sequelize';
+import { WhereOperators } from 'sequelize/types/lib/model';
 import { Collection } from './collection';
 import { Database } from './database';
 import mustHaveFilter from './decorators/must-have-filter-decorator';
@@ -18,6 +20,7 @@ import { transactionWrapperBuilder } from './decorators/transaction-decorator';
 import { RelationField } from './fields';
 import FilterParser from './filter-parser';
 import { Model } from './model';
+import operators from './operators';
 import { OptionsParser } from './options-parser';
 import { BelongsToManyRepository } from './relation-repository/belongs-to-many-repository';
 import { BelongsToRepository } from './relation-repository/belongs-to-repository';
@@ -45,7 +48,32 @@ export interface FilterAble {
 export type TargetKey = string | number;
 export type TK = TargetKey | TargetKey[];
 
-export type Filter = any;
+type FieldValue = string | number | bigint | boolean | Date | Buffer | null | FieldValue[] | FilterWithOperator;
+
+type Operators = keyof typeof operators & keyof WhereOperators;
+
+export type FilterWithOperator = {
+  [key: string]:
+    | {
+        [K in Operators]: FieldValue;
+      }
+    | FieldValue;
+};
+
+export type FilterWithValue = {
+  [key: string]: FieldValue;
+};
+
+type FilterAnd = {
+  $and: Filter[];
+};
+
+type FilterOr = {
+  $or: Filter[];
+};
+
+export type Filter = FilterWithOperator | FilterWithValue | FilterAnd | FilterOr;
+
 export type Appends = string[];
 export type Except = string[];
 export type Fields = string[];
@@ -53,12 +81,12 @@ export type Sort = string[] | string;
 
 export type WhiteList = string[];
 export type BlackList = string[];
+
 export type AssociationKeysToBeUpdate = string[];
 
 export type Values = any;
 
-export interface CountOptions extends Omit<SequelizeCreateOptions, 'distinct' | 'where' | 'include'>, Transactionable {
-  fields?: Fields;
+export interface CountOptions extends Omit<SequelizeCountOptions, 'distinct' | 'where' | 'include'>, Transactionable {
   filter?: Filter;
   context?: any;
 }
@@ -67,7 +95,7 @@ export interface FilterByTk {
   filterByTk?: TargetKey;
 }
 
-export interface FindOptions extends SequelizeFindOptions, CommonFindOptions, FilterByTk {}
+export type FindOptions = SequelizeFindOptions & CommonFindOptions & FilterByTk;
 
 export interface CommonFindOptions extends Transactionable {
   filter?: Filter;
@@ -78,7 +106,7 @@ export interface CommonFindOptions extends Transactionable {
   context?: any;
 }
 
-interface FindOneOptions extends FindOptions {}
+export type FindOneOptions = Omit<FindOptions, 'limit'>;
 
 export interface DestroyOptions extends SequelizeDestroyOptions {
   filter?: Filter;
@@ -87,18 +115,7 @@ export interface DestroyOptions extends SequelizeDestroyOptions {
   context?: any;
 }
 
-interface FindAndCountOptions extends Omit<SequelizeAndCountOptions, 'where' | 'include' | 'order'> {
-  // 数据过滤
-  filter?: Filter;
-  // 输出结果显示哪些字段
-  fields?: Fields;
-  // 输出结果不显示哪些字段
-  except?: Except;
-  // 附加字段，用于控制关系字段的输出
-  appends?: Appends;
-  // 排序，字段前面加上 “-” 表示降序
-  sort?: Sort;
-}
+type FindAndCountOptions = Omit<SequelizeAndCountOptions, 'where' | 'include' | 'order'> & CommonFindOptions;
 
 export interface CreateOptions extends SequelizeCreateOptions {
   values?: Values | Values[];
@@ -275,7 +292,10 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
       transaction,
     };
 
-    return [await this.find(options), await this.count(options)];
+    const count = await this.count(options);
+    const results = count ? await this.find(options) : [];
+
+    return [results, count];
   }
 
   /**
@@ -318,6 +338,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
     const guard = UpdateGuard.fromOptions(this.model, { ...options, action: 'create' });
     const values = guard.sanitize(options.values || {});
 
+
     const instance = await this.model.create<any>(values, {
       ...options,
       transaction,
@@ -358,6 +379,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
     const transaction = await this.getTransaction(options);
     const { records } = options;
     const instances = [];
+
     for (const values of records) {
       const instance = await this.create({ values, transaction });
       instances.push(instance);

package/src/types.ts

@@ -0,0 +1,64 @@
+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';
+
+export type CollectionNameType = string;
+
+export type ModelSyncEventType = 'beforeSync' | 'afterSync';
+export type ModelValidateEventType = 'beforeValidate' | 'afterValidate';
+export type ModelCreateEventType = 'beforeCreate' | 'afterCreate';
+export type ModelUpdateEventType = 'beforeUpdate' | 'afterUpdate';
+export type ModelSaveEventType = 'beforeSave' | 'afterSave';
+export type ModelDestroyEventType = 'beforeDestroy' | 'afterDestroy';
+export type ModelCreateWithAssociationsEventType = 'afterCreateWithAssociations';
+export type ModelUpdateWithAssociationsEventType = 'afterUpdateWithAssociations';
+export type ModelSaveWithAssociationsEventType = 'afterSaveWithAssociations';
+
+export type ModelValidateEventTypes = ModelValidateEventType | `${CollectionNameType}.${ModelValidateEventType}`;
+export type ModelCreateEventTypes = ModelCreateEventType | `${CollectionNameType}.${ModelCreateEventType}`;
+export type ModelUpdateEventTypes = ModelUpdateEventType | `${CollectionNameType}.${ModelUpdateEventType}`;
+export type ModelSaveEventTypes = ModelSaveEventType | `${CollectionNameType}.${ModelSaveEventType}`;
+export type ModelDestroyEventTypes = ModelDestroyEventType | `${CollectionNameType}.${ModelDestroyEventType}`;
+export type ModelCreateWithAssociationsEventTypes = ModelCreateWithAssociationsEventType | `${CollectionNameType}.${ModelCreateWithAssociationsEventType}`;
+export type ModelUpdateWithAssociationsEventTypes = ModelUpdateWithAssociationsEventType | `${CollectionNameType}.${ModelUpdateWithAssociationsEventType}`;
+export type ModelSaveWithAssociationsEventTypes = ModelSaveWithAssociationsEventType | `${CollectionNameType}.${ModelSaveWithAssociationsEventType}`;
+
+export type ModelEventTypes = ModelSyncEventType
+  | ModelValidateEventTypes
+  | ModelCreateEventTypes
+  | ModelUpdateEventTypes
+  | ModelSaveEventTypes
+  | ModelDestroyEventTypes
+  | ModelCreateWithAssociationsEventTypes
+  | ModelUpdateWithAssociationsEventTypes
+  | ModelSaveWithAssociationsEventTypes;
+
+export type DatabaseBeforeDefineCollectionEventType = 'beforeDefineCollection';
+export type DatabaseAfterDefineCollectionEventType = 'afterDefineCollection';
+export type DatabaseBeforeRemoveCollectionEventType = 'beforeRemoveCollection';
+export type DatabaseAfterRemoveCollectionEventType = 'afterRemoveCollection';
+
+export type DatabaseEventTypes = DatabaseBeforeDefineCollectionEventType
+  | DatabaseAfterDefineCollectionEventType
+  | DatabaseBeforeRemoveCollectionEventType
+  | DatabaseAfterRemoveCollectionEventType;
+
+export type EventType = ModelEventTypes | DatabaseEventTypes | string;
+
+export type { HookReturn };
+
+export type SyncListener = (options?: SyncOptions) => HookReturn;
+export type ValidateListener = (model: Model, options?: ValidationOptions) => HookReturn;
+export type CreateListener = (model: Model, options?: CreateOptions) => HookReturn;
+export type UpdateListener = (model: Model, options?: UpdateOptions) => HookReturn;
+export type SaveListener = (model: Model, options?: SaveOptions) => HookReturn;
+export type DestroyListener = (model: Model, options?: DestroyOptions) => HookReturn;
+export type CreateWithAssociationsListener = (model: Model, options?: CreateOptions) => HookReturn;
+export type UpdateWithAssociationsListener = (model: Model, options?: UpdateOptions) => HookReturn;
+export type SaveWithAssociationsListener = (model: Model, options?: SaveOptions) => HookReturn;
+
+export type BeforeDefineCollectionListener = (options: CollectionOptions) => void;
+export type AfterDefineCollectionListener = (collection: Collection) => void;
+export type RemoveCollectionListener = (collection: Collection) => void;