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

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;