@nocobase/database 0.5.0-alpha.38 → 0.7.0-alpha.10

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

@@ -0,0 +1,240 @@
+import lodash from 'lodash';
+import { BelongsToMany, Op, Transaction } from 'sequelize';
+import { Model } from '../model';
+import { CreateOptions, DestroyOptions, FindOptions, TargetKey, UpdateOptions } from '../repository';
+import { updateThroughTableValue } from '../update-associations';
+import { FindAndCountOptions, FindOneOptions, MultipleRelationRepository } from './multiple-relation-repository';
+import { transaction } from './relation-repository';
+import { AssociatedOptions, PrimaryKeyWithThroughValues } from './types';
+
+type CreateBelongsToManyOptions = CreateOptions;
+
+interface IBelongsToManyRepository<M extends Model> {
+  find(options?: FindOptions): Promise<M[]>;
+  findAndCount(options?: FindAndCountOptions): Promise<[M[], number]>;
+  findOne(options?: FindOneOptions): Promise<M>;
+  // 新增并关联，存在中间表数据
+  create(options?: CreateBelongsToManyOptions): Promise<M>;
+  // 更新，存在中间表数据
+  update(options?: UpdateOptions): Promise<M>;
+  // 删除
+  destroy(options?: number | string | number[] | string[] | DestroyOptions): Promise<Boolean>;
+  // 建立关联
+  set(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
+  // 附加关联，存在中间表数据
+  add(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
+  // 移除关联
+  remove(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
+  toggle(options: TargetKey | { pk?: TargetKey; transaction?: Transaction }): Promise<void>;
+}
+
+export class BelongsToManyRepository extends MultipleRelationRepository implements IBelongsToManyRepository<any> {
+  @transaction()
+  async create(options?: CreateBelongsToManyOptions): Promise<any> {
+    const transaction = await this.getTransaction(options);
+
+    const createAccessor = this.accessors().create;
+
+    const values = options.values || {};
+
+    const sourceModel = await this.getSourceModel(transaction);
+
+    const createOptions = {
+      ...options,
+      through: values[this.throughName()],
+      transaction,
+    };
+
+    return sourceModel[createAccessor](values, createOptions);
+  }
+
+  @transaction((args, transaction) => {
+    return {
+      filterByTk: args[0],
+      transaction,
+    };
+  })
+  async destroy(options?: TargetKey | TargetKey[] | DestroyOptions): Promise<Boolean> {
+    const transaction = await this.getTransaction(options);
+    const association = <BelongsToMany>this.association;
+
+    const instancesToIds = (instances) => {
+      return instances.map((instance) => instance.get(this.targetKey()));
+    };
+
+    // Through Table
+    const throughTableWhere: Array<any> = [
+      {
+        [association.foreignKey]: this.sourceKeyValue,
+      },
+    ];
+
+    let ids;
+
+    if (options && options['filter']) {
+      const instances = await this.find({
+        filter: options['filter'],
+        transaction,
+      });
+
+      ids = instancesToIds(instances);
+    }
+
+    if (options && options['filterByTk']) {
+      const instances = (<any>this.association).toInstanceArray(options['filterByTk']);
+      ids = ids ? lodash.intersection(ids, instancesToIds(instances)) : instancesToIds(instances);
+    }
+
+    if (options && !options['filterByTk'] && !options['filter']) {
+      const sourceModel = await this.getSourceModel(transaction);
+
+      const instances = await sourceModel[this.accessors().get]({
+        transaction,
+      });
+
+      ids = instancesToIds(instances);
+    }
+
+    throughTableWhere.push({
+      [association.otherKey]: {
+        [Op.in]: ids,
+      },
+    });
+
+    // delete through table data
+    await this.throughModel().destroy({
+      where: throughTableWhere,
+      transaction,
+    });
+
+    await this.targetModel.destroy({
+      where: {
+        [this.targetKey()]: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    return true;
+  }
+
+  protected async setTargets(
+    call: 'add' | 'set',
+    options: TargetKey | TargetKey[] | PrimaryKeyWithThroughValues | PrimaryKeyWithThroughValues[] | AssociatedOptions,
+  ) {
+    let handleKeys: TargetKey[] | PrimaryKeyWithThroughValues[];
+
+    const transaction = await this.getTransaction(options, false);
+
+    if (lodash.isPlainObject(options)) {
+      options = (<AssociatedOptions>options).tk || [];
+    }
+
+    if (lodash.isString(options) || lodash.isNumber(options)) {
+      handleKeys = [<TargetKey>options];
+    } // if it is type primaryKeyWithThroughValues
+    else if (lodash.isArray(options) && options.length == 2 && lodash.isPlainObject(options[0][1])) {
+      handleKeys = [<PrimaryKeyWithThroughValues>options];
+    } else {
+      handleKeys = <TargetKey[] | PrimaryKeyWithThroughValues[]>options;
+    }
+
+    const sourceModel = await this.getSourceModel(transaction);
+
+    const setObj = (<any>handleKeys).reduce((carry, item) => {
+      if (Array.isArray(item)) {
+        carry[item[0]] = item[1];
+      } else {
+        carry[item] = true;
+      }
+      return carry;
+    }, {});
+
+    await sourceModel[this.accessors()[call]](Object.keys(setObj), {
+      transaction,
+    });
+
+    for (const [id, throughValues] of Object.entries(setObj)) {
+      if (typeof throughValues === 'object') {
+        const instance = await this.targetModel.findByPk(id, {
+          transaction,
+        });
+        await updateThroughTableValue(instance, this.throughName(), throughValues, sourceModel, transaction);
+      }
+    }
+  }
+
+  @transaction((args, transaction) => {
+    return {
+      tk: args[0],
+      transaction,
+    };
+  })
+  async add(
+    options: TargetKey | TargetKey[] | PrimaryKeyWithThroughValues | PrimaryKeyWithThroughValues[] | AssociatedOptions,
+  ): Promise<void> {
+    await this.setTargets('add', options);
+  }
+
+  @transaction((args, transaction) => {
+    return {
+      tk: args[0],
+      transaction,
+    };
+  })
+  async set(
+    options: TargetKey | TargetKey[] | PrimaryKeyWithThroughValues | PrimaryKeyWithThroughValues[] | AssociatedOptions,
+  ): Promise<void> {
+    await this.setTargets('set', options);
+  }
+
+  @transaction((args, transaction) => {
+    return {
+      tk: args[0],
+      transaction,
+    };
+  })
+  async toggle(options: TargetKey | { tk?: TargetKey; transaction?: Transaction }): Promise<void> {
+    const transaction = await this.getTransaction(options);
+    const sourceModel = await this.getSourceModel(transaction);
+
+    const has = await sourceModel[this.accessors().hasSingle](options['tk'], {
+      transaction,
+    });
+
+    if (has) {
+      await this.remove({
+        ...(<any>options),
+        transaction,
+      });
+    } else {
+      await this.add({
+        ...(<any>options),
+        transaction,
+      });
+    }
+
+    return;
+  }
+
+  extendFindOptions(findOptions) {
+    let joinTableAttributes;
+    if (lodash.get(findOptions, 'fields')) {
+      joinTableAttributes = [];
+    }
+
+    return {
+      ...findOptions,
+      joinTableAttributes,
+    };
+  }
+
+  throughName() {
+    return this.throughModel().name;
+  }
+
+  throughModel() {
+    return (<any>this.association).through.model;
+  }
+}

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

@@ -0,0 +1,23 @@
+import { Model } from '../model';
+import { CreateOptions, UpdateOptions } from '../repository';
+import { SingleRelationFindOption, SingleRelationRepository } from './single-relation-repository';
+
+interface BelongsToFindOptions extends SingleRelationFindOption {}
+
+interface IBelongsToRepository<M extends Model> {
+  // 不需要 findOne，find 就是 findOne
+  find(options?: BelongsToFindOptions): Promise<M>;
+  findOne(options?: BelongsToFindOptions): Promise<M>;
+  // 新增并关联，如果存在关联，解除之后，与新数据建立关联
+  create(options?: CreateOptions): Promise<M>;
+  // 更新
+  update(options?: UpdateOptions): Promise<M>;
+  // 删除
+  destroy(): Promise<Boolean>;
+  // 建立关联
+  set(primaryKey: any): Promise<void>;
+  // 移除关联
+  remove(): Promise<void>;
+}
+
+export class BelongsToRepository extends SingleRelationRepository implements IBelongsToRepository<any> {}

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

@@ -0,0 +1,145 @@
+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,
+  FindOneOptions,
+  MultipleRelationRepository
+} from './multiple-relation-repository';
+import { transaction } from './relation-repository';
+
+interface IHasManyRepository<M extends Model> {
+  find(options?: FindOptions): Promise<M>;
+  findAndCount(options?: FindAndCountOptions): Promise<[M[], number]>;
+  findOne(options?: FindOneOptions): Promise<M>;
+  // 新增并关联
+  create(options?: CreateOptions): Promise<M>;
+  // 更新
+  update(options?: UpdateOptions): Promise<M>;
+  // 删除
+  destroy(options?: TK | DestroyOptions): Promise<Boolean>;
+  // 建立关联
+  set(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
+  // 附加关联
+  add(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
+  // 移除关联
+  remove(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
+}
+
+export class HasManyRepository extends MultipleRelationRepository implements IHasManyRepository<any> {
+  async find(options?: FindOptions): Promise<any> {
+    const targetRepository = this.targetCollection.repository;
+
+    const addFilter = {
+      [this.association.foreignKey]: this.sourceKeyValue,
+    };
+
+    if (options?.filterByTk) {
+      addFilter[this.associationField.targetKey] = options.filterByTk;
+    }
+
+    return await targetRepository.find({
+      ...omit(options, ['filterByTk']),
+      filter: {
+        $and: [options.filter || {}, addFilter],
+      },
+    });
+  }
+
+  @transaction((args, transaction) => {
+    return {
+      filterByTk: args[0],
+      transaction,
+    };
+  })
+  async destroy(options?: TK | DestroyOptions): Promise<Boolean> {
+    const transaction = await this.getTransaction(options);
+
+    const sourceModel = await this.getSourceModel(transaction);
+
+    const where = [
+      {
+        [this.association.foreignKey]: sourceModel.get((this.association as any).sourceKey),
+      },
+    ];
+
+    if (options && options['filter']) {
+      const filterResult = this.parseFilter(options['filter'], options);
+
+      if (filterResult.include && filterResult.include.length > 0) {
+        return await this.destroyByFilter(options['filter'], transaction);
+      }
+
+      where.push(filterResult.where);
+    }
+
+    if (options && options['filterByTk']) {
+      if (typeof options === 'object' && options['filterByTk']) {
+        options = options['filterByTk'];
+      }
+
+      where.push({
+        [this.targetKey()]: options,
+      });
+    }
+
+    await this.targetModel.destroy({
+      where: {
+        [Op.and]: where,
+      },
+      individualHooks: true,
+      transaction,
+    });
+
+    return true;
+  }
+
+  handleKeyOfAdd(options) {
+    let handleKeys;
+
+    if (typeof options !== 'object' && !Array.isArray(options)) {
+      handleKeys = [options];
+    } else {
+      handleKeys = options['pk'];
+    }
+    return handleKeys;
+  }
+
+  @transaction((args, transaction) => {
+    return {
+      pk: args[0],
+      transaction,
+    };
+  })
+  async set(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void> {
+    const transaction = await this.getTransaction(options);
+
+    const sourceModel = await this.getSourceModel(transaction);
+
+    await sourceModel[this.accessors().set](this.handleKeyOfAdd(options), {
+      transaction,
+    });
+  }
+
+  @transaction((args, transaction) => {
+    return {
+      pk: args[0],
+      transaction,
+    };
+  })
+  async add(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void> {
+    const transaction = await this.getTransaction(options);
+
+    const sourceModel = await this.getSourceModel(transaction);
+
+    await sourceModel[this.accessors().add](this.handleKeyOfAdd(options), {
+      transaction,
+    });
+  }
+
+  accessors() {
+    return (<HasMany>this.association).accessors;
+  }
+}

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

@@ -0,0 +1,23 @@
+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>;
+  // 新增并关联，如果存在关联，解除之后，与新数据建立关联
+  create(options?: CreateOptions): Promise<M>;
+  // 更新
+  update(options?): Promise<M>;
+  // 删除
+  destroy(): Promise<Boolean>;
+  // 建立关联
+  set(primaryKey: any): Promise<void>;
+  // 移除关联
+  remove(): Promise<void>;
+}
+
+export class HasOneRepository extends SingleRelationRepository implements IHasOneRepository<any> {}

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

@@ -0,0 +1,198 @@
+import { omit } from 'lodash';
+import { MultiAssociationAccessors, Op, Sequelize, Transaction } from 'sequelize';
+import {
+  CommonFindOptions,
+  CountOptions,
+  DestroyOptions,
+  Filter,
+  FilterByTk,
+  FindOptions,
+  TargetKey,
+  TK,
+  TransactionAble,
+  UpdateOptions
+} from '../repository';
+import { updateModelByValues } from '../update-associations';
+import { UpdateGuard } from '../update-guard';
+import { RelationRepository, transaction } from './relation-repository';
+
+export interface FindAndCountOptions extends CommonFindOptions {}
+
+export interface FindOneOptions extends CommonFindOptions, FilterByTk {}
+
+export interface AssociatedOptions extends TransactionAble {
+  tk?: TK;
+}
+
+export abstract class MultipleRelationRepository extends RelationRepository {
+  extendFindOptions(findOptions) {
+    return findOptions;
+  }
+
+  async find(options?: FindOptions): Promise<any> {
+    const transaction = await this.getTransaction(options);
+
+    const findOptions = {
+      ...this.extendFindOptions(
+        this.buildQueryOptions({
+          ...options,
+        }),
+      ),
+      subQuery: false,
+    };
+
+    const getAccessor = this.accessors().get;
+    const sourceModel = await this.getSourceModel(transaction);
+
+    if (findOptions.include && findOptions.include.length > 0) {
+      const ids = (
+        await sourceModel[getAccessor]({
+          ...findOptions,
+          includeIgnoreAttributes: false,
+          attributes: [this.targetKey()],
+          group: `${this.targetModel.name}.${this.targetKey()}`,
+          transaction,
+        })
+      ).map((row) => row.get(this.targetKey()));
+
+      return await sourceModel[getAccessor]({
+        ...omit(findOptions, ['limit', 'offset']),
+        where: {
+          [this.targetKey()]: {
+            [Op.in]: ids,
+          },
+        },
+        transaction,
+      });
+    }
+
+    return await sourceModel[getAccessor]({
+      ...findOptions,
+      transaction,
+    });
+  }
+
+  async findAndCount(options?: FindAndCountOptions): Promise<[any[], number]> {
+    const transaction = await this.getTransaction(options, false);
+    return [
+      await this.find({
+        ...options,
+        transaction,
+      }),
+      await this.count({
+        ...options,
+        transaction,
+      }),
+    ];
+  }
+
+  async count(options?: CountOptions) {
+    const transaction = await this.getTransaction(options);
+
+    const sourceModel = await this.getSourceModel(transaction);
+    const queryOptions = this.buildQueryOptions(options);
+
+    const count = await sourceModel[this.accessors().get]({
+      where: queryOptions.where,
+      include: queryOptions.include,
+      includeIgnoreAttributes: false,
+      attributes: [
+        [
+          Sequelize.fn(
+            'COUNT',
+            Sequelize.fn('DISTINCT', Sequelize.col(`${this.targetModel.name}.${this.targetKey()}`)),
+          ),
+          'count',
+        ],
+      ],
+      raw: true,
+      plain: true,
+      transaction,
+    });
+
+    return parseInt(count.count);
+  }
+
+  async findOne(options?: FindOneOptions): Promise<any> {
+    const transaction = await this.getTransaction(options, false);
+    const rows = await this.find({ ...options, limit: 1, transaction });
+    return rows.length == 1 ? rows[0] : null;
+  }
+
+  @transaction((args, transaction) => {
+    return {
+      tk: args[0],
+      transaction,
+    };
+  })
+  async remove(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void> {
+    const transaction = await this.getTransaction(options);
+    let handleKeys = options['tk'];
+
+    if (!Array.isArray(handleKeys)) {
+      handleKeys = [handleKeys];
+    }
+
+    const sourceModel = await this.getSourceModel(transaction);
+    await sourceModel[this.accessors().removeMultiple](handleKeys, {
+      transaction,
+    });
+    return;
+  }
+
+  @transaction()
+  async update(options?: UpdateOptions): Promise<any> {
+    const transaction = await this.getTransaction(options);
+
+    const guard = UpdateGuard.fromOptions(this.targetModel, options);
+
+    const values = guard.sanitize(options.values);
+
+    const queryOptions = this.buildQueryOptions(options as any);
+
+    const instances = await this.find(queryOptions);
+
+    for (const instance of instances) {
+      await updateModelByValues(instance, values, {
+        ...options,
+        sanitized: true,
+        sourceModel: this.sourceInstance,
+        transaction,
+      });
+    }
+
+    for (const instance of instances) {
+      if (options.hooks !== false) {
+        await this.db.emitAsync(`${this.targetCollection.name}.afterUpdateWithAssociations`, instance, options);
+        await this.db.emitAsync(`${this.targetCollection.name}.afterSaveWithAssociations`, instance, options);
+      }
+    }
+
+    return instances;
+  }
+
+  async destroy(options?: TK | DestroyOptions): Promise<Boolean> {
+    return false;
+  }
+
+  protected async destroyByFilter(filter: Filter, transaction?: Transaction) {
+    const instances = await this.find({
+      filter: filter,
+      transaction,
+    });
+
+    return await this.destroy({
+      filterByTk: instances.map((instance) => instance.get(this.targetCollection.filterTargetKey)),
+      transaction,
+    });
+  }
+
+  protected filterHasInclude(filter: Filter, options?: any) {
+    const filterResult = this.parseFilter(filter, options);
+    return filterResult.include && filterResult.include.length > 0;
+  }
+
+  protected accessors() {
+    return <MultiAssociationAccessors>super.accessors();
+  }
+}