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

package/src/transaction-decorator.ts

@@ -0,0 +1,58 @@
+import lodash from 'lodash';
+
+export function transactionWrapperBuilder(transactionGenerator) {
+  return function transaction(transactionInjector?) {
+    return (target, name, descriptor) => {
+      const oldValue = descriptor.value;
+
+      descriptor.value = async function () {
+        let transaction;
+        let newTransaction = false;
+
+        if (arguments.length > 0 && typeof arguments[0] === 'object') {
+          transaction = arguments[0]['transaction'];
+        }
+
+        if (!transaction) {
+          transaction = await transactionGenerator.apply(this);
+          newTransaction = true;
+        }
+
+        // 需要将 newTransaction 注入到被装饰函数参数内
+        if (newTransaction) {
+          try {
+            let callArguments;
+            if (lodash.isPlainObject(arguments[0])) {
+              callArguments = {
+                ...arguments[0],
+                transaction,
+              };
+            } else if (transactionInjector) {
+              callArguments = transactionInjector(arguments, transaction);
+            } else if (lodash.isNull(arguments[0]) || lodash.isUndefined(arguments[0])) {
+              callArguments = {
+                transaction,
+              };
+            } else {
+              throw new Error(`please provide transactionInjector for ${name} call`);
+            }
+
+            const results = await oldValue.apply(this, [callArguments]);
+
+            await transaction.commit();
+
+            return results;
+          } catch (err) {
+            console.error({ err });
+            await transaction.rollback();
+            throw err;
+          }
+        } else {
+          return oldValue.apply(this, arguments);
+        }
+      };
+
+      return descriptor;
+    };
+  };
+}

package/src/update-associations.ts

@@ -0,0 +1,478 @@
+import {
+  Association,
+  BelongsTo,
+  BelongsToMany,
+  HasMany,
+  HasOne,
+  Hookable,
+  ModelCtor,
+  Transactionable,
+} from 'sequelize';
+import { Model } from './model';
+import { TransactionAble } from './repository';
+import { UpdateGuard } from './update-guard';
+
+function isUndefinedOrNull(value: any) {
+  return typeof value === 'undefined' || value === null;
+}
+
+function isStringOrNumber(value: any) {
+  return typeof value === 'string' || typeof value === 'number';
+}
+
+function getKeysByPrefix(keys: string[], prefix: string) {
+  return keys.filter((key) => key.startsWith(`${prefix}.`)).map((key) => key.substring(prefix.length + 1));
+}
+
+export function modelAssociations(instance: Model) {
+  return (<typeof Model>instance.constructor).associations;
+}
+
+export function belongsToManyAssociations(instance: Model): Array<BelongsToMany> {
+  const associations = modelAssociations(instance);
+  return Object.entries(associations)
+    .filter((entry) => {
+      const [key, association] = entry;
+      return association.associationType == 'BelongsToMany';
+    })
+    .map((association) => {
+      return <BelongsToMany>association[1];
+    });
+}
+
+export function modelAssociationByKey(instance: Model, key: string): Association {
+  return modelAssociations(instance)[key] as Association;
+}
+
+type UpdateValue = { [key: string]: any };
+
+interface UpdateOptions extends TransactionAble {
+  filter?: any;
+  filterByTk?: number | string;
+  // 字段白名单
+  whitelist?: string[];
+  // 字段黑名单
+  blacklist?: string[];
+  // 关系数据默认会新建并建立关联处理，如果是已存在的数据只关联，但不更新关系数据
+  // 如果需要更新关联数据，可以通过 updateAssociationValues 指定
+  updateAssociationValues?: string[];
+  sanitized?: boolean;
+  sourceModel?: Model;
+}
+
+interface UpdateAssociationOptions extends Transactionable, Hookable {
+  updateAssociationValues?: string[];
+  sourceModel?: Model;
+  context?: any;
+  associationContext?: any;
+}
+
+export async function updateModelByValues(instance: Model, values: UpdateValue, options?: UpdateOptions) {
+  if (!options?.sanitized) {
+    const guard = new UpdateGuard();
+    //@ts-ignore
+    guard.setModel(instance.constructor);
+    guard.setBlackList(options.blacklist);
+    guard.setWhiteList(options.whitelist);
+    guard.setAssociationKeysToBeUpdate(options.updateAssociationValues);
+    values = guard.sanitize(values);
+  }
+
+  await instance.update(values, options);
+  await updateAssociations(instance, values, options);
+}
+
+export async function updateThroughTableValue(
+  instance: Model,
+  throughName: string,
+  throughValues: any,
+  source: Model,
+  transaction = null,
+) {
+  // update through table values
+  for (const belongsToMany of belongsToManyAssociations(instance)) {
+    // @ts-ignore
+    const throughModel = belongsToMany.through.model;
+    const throughModelName = throughModel.name;
+
+    if (throughModelName === throughModelName) {
+      const where = {
+        [belongsToMany.foreignKey]: instance.get(belongsToMany.sourceKey),
+        [belongsToMany.otherKey]: source.get(belongsToMany.targetKey),
+      };
+
+      return await throughModel.update(throughValues, {
+        where,
+        transaction,
+      });
+    }
+  }
+}
+
+/**
+ * update association of instance by values
+ * @param instance
+ * @param values
+ * @param options
+ */
+export async function updateAssociations(instance: Model, values: any, options: UpdateAssociationOptions = {}) {
+  // if no values set, return
+  if (!values) {
+    return;
+  }
+
+  let newTransaction = false;
+  let transaction = options.transaction;
+
+  if (!transaction) {
+    newTransaction = true;
+    transaction = await instance.sequelize.transaction();
+  }
+
+  const keys = Object.keys(values);
+
+  for (const key of Object.keys(modelAssociations(instance))) {
+    if (keys.includes(key)) {
+      await updateAssociation(instance, key, values[key], {
+        ...options,
+        transaction,
+      });
+    }
+  }
+
+  // update through table values
+  for (const belongsToMany of belongsToManyAssociations(instance)) {
+    // @ts-ignore
+    const throughModel = belongsToMany.through.model;
+    const throughModelName = throughModel.name;
+
+    if (values[throughModelName] && options.sourceModel) {
+      const where = {
+        [belongsToMany.foreignKey]: instance.get(belongsToMany.sourceKey),
+        [belongsToMany.otherKey]: options.sourceModel.get(belongsToMany.targetKey),
+      };
+
+      await throughModel.update(values[throughModel.name], {
+        where,
+        context: options.context,
+        transaction,
+      });
+    }
+  }
+
+  if (newTransaction) {
+    await transaction.commit();
+  }
+}
+
+function isReverseAssociationPair(a: any, b: any) {
+  const typeSet = new Set();
+  typeSet.add(a.associationType);
+  typeSet.add(b.associationType);
+
+  if (typeSet.size == 1 && typeSet.has('BelongsToMany')) {
+    return (
+      a.through.tableName === b.through.tableName &&
+      a.target.name === b.source.name &&
+      b.target.name === a.source.name &&
+      a.foreignKey === b.otherKey &&
+      a.sourceKey === b.targetKey &&
+      a.otherKey === b.foreignKey &&
+      a.targetKey === b.sourceKey
+    );
+  }
+
+  if ((typeSet.has('HasOne') && typeSet.has('BelongsTo')) || (typeSet.has('HasMany') && typeSet.has('BelongsTo'))) {
+    const sourceAssoc = a.associationType == 'BelongsTo' ? b : a;
+    const targetAssoc = sourceAssoc == a ? b : a;
+
+    return (
+      sourceAssoc.source.name === targetAssoc.target.name &&
+      sourceAssoc.foreignKey === targetAssoc.foreignKey &&
+      sourceAssoc.sourceKey === targetAssoc.targetKey
+    );
+  }
+
+  return false;
+}
+
+/**
+ * update model association by key
+ * @param instance
+ * @param key
+ * @param value
+ * @param options
+ */
+export async function updateAssociation(
+  instance: Model,
+  key: string,
+  value: any,
+  options: UpdateAssociationOptions = {},
+) {
+  const association = modelAssociationByKey(instance, key);
+
+  if (!association) {
+    return false;
+  }
+
+  if (options.associationContext && isReverseAssociationPair(association, options.associationContext)) {
+    return false;
+  }
+
+  switch (association.associationType) {
+    case 'HasOne':
+    case 'BelongsTo':
+      return updateSingleAssociation(instance, key, value, options);
+    case 'HasMany':
+    case 'BelongsToMany':
+      return updateMultipleAssociation(instance, key, value, options);
+  }
+}
+
+/**
+ * update belongsTo and HasOne
+ * @param model
+ * @param key
+ * @param value
+ * @param options
+ */
+export async function updateSingleAssociation(
+  model: Model,
+  key: string,
+  value: any,
+  options: UpdateAssociationOptions = {},
+) {
+  const association = <HasOne | BelongsTo>modelAssociationByKey(model, key);
+
+  if (!association) {
+    return false;
+  }
+
+  if (!['undefined', 'string', 'number', 'object'].includes(typeof value)) {
+    return false;
+  }
+
+  const { context, updateAssociationValues = [], transaction = await model.sequelize.transaction() } = options;
+  const keys = getKeysByPrefix(updateAssociationValues, key);
+
+  try {
+    // set method of association
+    const setAccessor = association.accessors.set;
+
+    const removeAssociation = async () => {
+      await model[setAccessor](null, { transaction });
+      model.setDataValue(key, null);
+      if (!options.transaction) {
+        await transaction.commit();
+      }
+      return true;
+    };
+
+    if (isUndefinedOrNull(value)) {
+      return await removeAssociation();
+    }
+
+    if (isStringOrNumber(value)) {
+      await model[setAccessor](value, { context, transaction });
+      if (!options.transaction) {
+        await transaction.commit();
+      }
+      return true;
+    }
+
+    if (value instanceof Model) {
+      await model[setAccessor](value, { context, transaction });
+      model.setDataValue(key, value);
+
+      if (!options.transaction) {
+        await transaction.commit();
+      }
+      return true;
+    }
+
+    const createAccessor = association.accessors.create;
+    let dataKey: string;
+    let M: ModelCtor<Model>;
+    if (association.associationType === 'BelongsTo') {
+      M = association.target as ModelCtor<Model>;
+      // @ts-ignore
+      dataKey = association.targetKey;
+    } else {
+      M = association.source as ModelCtor<Model>;
+      dataKey = M.primaryKeyAttribute;
+    }
+
+    if (isStringOrNumber(value[dataKey])) {
+      let instance: any = await M.findOne({
+        where: {
+          [dataKey]: value[dataKey],
+        },
+        transaction,
+      });
+
+      if (instance) {
+        await model[setAccessor](instance, { context, transaction });
+
+        if (updateAssociationValues.includes(key)) {
+          await instance.update(value, { ...options, transaction });
+        }
+
+        await updateAssociations(instance, value, {
+          ...options,
+          transaction,
+          associationContext: association,
+          updateAssociationValues: keys,
+        });
+        model.setDataValue(key, instance);
+        if (!options.transaction) {
+          await transaction.commit();
+        }
+        return true;
+      }
+    }
+
+    const instance = await model[createAccessor](value, { context, transaction });
+    await updateAssociations(instance, value, {
+      ...options,
+      transaction,
+      associationContext: association,
+      updateAssociationValues: keys,
+    });
+    model.setDataValue(key, instance);
+    // @ts-ignore
+    if (association.targetKey) {
+      model.setDataValue(association.foreignKey, instance[dataKey]);
+    }
+    if (!options.transaction) {
+      await transaction.commit();
+    }
+  } catch (error) {
+    if (!options.transaction) {
+      await transaction.rollback();
+    }
+    throw error;
+  }
+}
+
+/**
+ * update multiple association of model by value
+ * @param model
+ * @param key
+ * @param value
+ * @param options
+ */
+export async function updateMultipleAssociation(
+  model: Model,
+  key: string,
+  value: any,
+  options: UpdateAssociationOptions = {},
+) {
+  const association = <BelongsToMany | HasMany>modelAssociationByKey(model, key);
+
+  if (!association) {
+    return false;
+  }
+
+  if (!['undefined', 'string', 'number', 'object'].includes(typeof value)) {
+    return false;
+  }
+
+  const { context, updateAssociationValues = [], transaction = await model.sequelize.transaction() } = options;
+  const keys = getKeysByPrefix(updateAssociationValues, key);
+
+  try {
+    const setAccessor = association.accessors.set;
+
+    const createAccessor = association.accessors.create;
+    if (isUndefinedOrNull(value)) {
+      await model[setAccessor](null, { transaction, context });
+      model.setDataValue(key, null);
+      return;
+    }
+
+    if (isStringOrNumber(value)) {
+      await model[setAccessor](value, { transaction, context });
+      return;
+    }
+
+    if (!Array.isArray(value)) {
+      value = [value];
+    }
+
+    const list1 = []; // to be setted
+    const list2 = []; // to be added
+    for (const item of value) {
+      if (isUndefinedOrNull(item)) {
+        continue;
+      }
+      if (isStringOrNumber(item)) {
+        list1.push(item);
+      } else if (item instanceof Model) {
+        list1.push(item);
+      } else if (item.sequelize) {
+        list1.push(item);
+      } else if (typeof item === 'object') {
+        list2.push(item);
+      }
+    }
+
+    // associate targets in lists1
+    await model[setAccessor](list1, { transaction, context });
+
+    const list3 = [];
+    for (const item of list2) {
+      const pk = association.target.primaryKeyAttribute;
+
+      const through = (<any>association).through ? (<any>association).through.model.name : null;
+
+      const accessorOptions = {
+        context,
+        transaction,
+      };
+
+      const throughValue = item[through];
+
+      if (throughValue) {
+        accessorOptions['through'] = throughValue;
+      }
+
+      if (isUndefinedOrNull(item[pk])) {
+        // create new record
+        const instance = await model[createAccessor](item, accessorOptions);
+        await updateAssociations(instance, item, {
+          ...options,
+          transaction,
+          associationContext: association,
+          updateAssociationValues: keys,
+        });
+        list3.push(instance);
+      } else {
+        // set & update record
+        const instance = await association.target.findByPk<any>(item[pk], {
+          transaction,
+        });
+        const addAccessor = association.accessors.add;
+
+        await model[addAccessor](item[pk], accessorOptions);
+        if (updateAssociationValues.includes(key)) {
+          await instance.update(item, { ...options, transaction });
+        }
+        await updateAssociations(instance, item, {
+          ...options,
+          transaction,
+          associationContext: association,
+          updateAssociationValues: keys,
+        });
+        list3.push(instance);
+      }
+    }
+
+    model.setDataValue(key, list1.concat(list3));
+    if (!options.transaction) {
+      await transaction.commit();
+    }
+  } catch (error) {
+    await transaction.rollback();
+    throw error;
+  }
+}

package/src/update-guard.ts

@@ -0,0 +1,167 @@
+import lodash from 'lodash';
+import { ModelCtor } from 'sequelize';
+import { Model } from './model';
+import { AssociationKeysToBeUpdate, BlackList, WhiteList } from './repository';
+
+type UpdateValueItem = string | number | UpdateValues;
+
+type UpdateValues = {
+  [key: string]: UpdateValueItem | Array<UpdateValueItem>;
+};
+
+type UpdateAction = 'create' | 'update';
+export class UpdateGuard {
+  model: ModelCtor<any>;
+  action: UpdateAction;
+  private associationKeysToBeUpdate: AssociationKeysToBeUpdate;
+  private blackList: BlackList;
+  private whiteList: WhiteList;
+
+  setAction(action: UpdateAction) {
+    this.action = action;
+  }
+
+  setModel(model: ModelCtor<any>) {
+    this.model = model;
+  }
+
+  setAssociationKeysToBeUpdate(associationKeysToBeUpdate: AssociationKeysToBeUpdate) {
+    if (this.action == 'create') {
+      this.associationKeysToBeUpdate = Object.keys(this.model.associations);
+    } else {
+      this.associationKeysToBeUpdate = associationKeysToBeUpdate;
+    }
+  }
+
+  setWhiteList(whiteList: WhiteList) {
+    this.whiteList = whiteList;
+  }
+
+  setBlackList(blackList: BlackList) {
+    this.blackList = blackList;
+  }
+
+  /**
+   * Sanitize values by whitelist blacklist
+   * @param values
+   */
+  sanitize(values: UpdateValues) {
+    values = lodash.clone(values);
+
+    if (!this.model) {
+      throw new Error('please set model first');
+    }
+
+    const associations = this.model.associations;
+    const associationsValues = lodash.pick(values, Object.keys(associations));
+
+    // build params of association update guard
+    const listOfAssociation = (list, association) => {
+      if (list) {
+        list = list
+          .filter((whiteListKey) => whiteListKey.startsWith(`${association}.`))
+          .map((whiteListKey) => whiteListKey.replace(`${association}.`, ''));
+
+        if (list.length == 0) {
+          return undefined;
+        }
+
+        return list;
+      }
+
+      return undefined;
+    };
+
+    // sanitize association values
+    Object.keys(associationsValues).forEach((association) => {
+      let associationValues = associationsValues[association];
+
+      const filterAssociationToBeUpdate = (value) => {
+        const associationKeysToBeUpdate = this.associationKeysToBeUpdate || [];
+
+        if (associationKeysToBeUpdate.includes(association)) {
+          return value;
+        }
+
+        const associationObj = associations[association];
+
+        const associationKeyName =
+          associationObj.associationType == 'BelongsTo' || associationObj.associationType == 'HasOne'
+            ? (<any>associationObj).targetKey
+            : associationObj.target.primaryKeyAttribute;
+
+        if (value[associationKeyName]) {
+          return lodash.pick(value, [associationKeyName, ...Object.keys(associationObj.target.associations)]);
+        }
+
+        return value;
+      };
+
+      const sanitizeValue = (value) => {
+        const associationUpdateGuard = new UpdateGuard();
+        associationUpdateGuard.setModel(associations[association].target);
+
+        ['whiteList', 'blackList', 'associationKeysToBeUpdate'].forEach((optionKey) => {
+          associationUpdateGuard[`set${lodash.upperFirst(optionKey)}`](listOfAssociation(this[optionKey], association));
+        });
+
+        return associationUpdateGuard.sanitize(filterAssociationToBeUpdate(value));
+      };
+
+      if (Array.isArray(associationValues)) {
+        associationValues = associationValues.map((value) => {
+          if (typeof value == 'string' || typeof value == 'number') {
+            return value;
+          } else {
+            return sanitizeValue(value);
+          }
+        });
+      } else if (typeof associationValues === 'object' && associationValues !== null) {
+        associationValues = sanitizeValue(associationValues);
+      }
+
+      // set association values to sanitized value
+      values[association] = associationValues;
+    });
+
+    if (values instanceof Model) {
+      return values;
+    }
+
+    let valuesKeys = Object.keys(values || {});
+
+    // handle whitelist
+    if (this.whiteList) {
+      valuesKeys = valuesKeys.filter((valueKey) => {
+        return (
+          this.whiteList.findIndex((whiteKey) => {
+            const keyPaths = whiteKey.split('.');
+            return keyPaths[0] === valueKey;
+          }) !== -1
+        );
+      });
+    }
+
+    // handle blacklist
+    if (this.blackList) {
+      valuesKeys = valuesKeys.filter((valueKey) => !this.blackList.includes(valueKey));
+    }
+
+    const result = valuesKeys.reduce((obj, key) => {
+      lodash.set(obj, key, values[key]);
+      return obj;
+    }, {});
+
+    return result;
+  }
+
+  static fromOptions(model, options) {
+    const guard = new UpdateGuard();
+    guard.setModel(model);
+    guard.setWhiteList(options.whitelist);
+    guard.setBlackList(options.blacklist);
+    guard.setAction(lodash.get(options, 'action', 'update'));
+    guard.setAssociationKeysToBeUpdate(options.updateAssociationValues);
+    return guard;
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../../tsconfig.build.json",
+  "compilerOptions": {
+    "outDir": "./lib",
+    "declaration": true
+  },
+  "include": ["./src/**/*.ts", "./src/**/*.tsx"],
+  "exclude": ["./src/__tests__/*", "./esm/*", "./lib/*"]
+}

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../../tsconfig.json",
+  "include": ["./src/**/*.ts", "./src/**/*.tsx"],
+  "exclude": ["./esm/*", "./lib/*"]
+}