@nocobase/database 1.2.13-alpha → 1.3.0-alpha.20240710084543

package/lib/update-associations.js

@@ -1,429 +0,0 @@
-/**
- * This file is part of the NocoBase (R) project.
- * Copyright (c) 2020-2024 NocoBase Co., Ltd.
- * Authors: NocoBase Team.
- *
- * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
- * For more information, please refer to: https://www.nocobase.com/agreement.
- */
-
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var update_associations_exports = {};
-__export(update_associations_exports, {
-  belongsToManyAssociations: () => belongsToManyAssociations,
-  modelAssociationByKey: () => modelAssociationByKey,
-  modelAssociations: () => modelAssociations,
-  updateAssociation: () => updateAssociation,
-  updateAssociations: () => updateAssociations,
-  updateModelByValues: () => updateModelByValues,
-  updateMultipleAssociation: () => updateMultipleAssociation,
-  updateSingleAssociation: () => updateSingleAssociation,
-  updateThroughTableValue: () => updateThroughTableValue
-});
-module.exports = __toCommonJS(update_associations_exports);
-var import_lodash = __toESM(require("lodash"));
-var import_model = require("./model");
-var import_update_guard = require("./update-guard");
-function isUndefinedOrNull(value) {
-  return typeof value === "undefined" || value === null;
-}
-__name(isUndefinedOrNull, "isUndefinedOrNull");
-function isStringOrNumber(value) {
-  return typeof value === "string" || typeof value === "number";
-}
-__name(isStringOrNumber, "isStringOrNumber");
-function getKeysByPrefix(keys, prefix) {
-  return keys.filter((key) => key.startsWith(`${prefix}.`)).map((key) => key.substring(prefix.length + 1));
-}
-__name(getKeysByPrefix, "getKeysByPrefix");
-function modelAssociations(instance) {
-  return instance.constructor.associations;
-}
-__name(modelAssociations, "modelAssociations");
-function belongsToManyAssociations(instance) {
-  const associations = modelAssociations(instance);
-  return Object.entries(associations).filter((entry) => {
-    const [key, association] = entry;
-    return association.associationType == "BelongsToMany";
-  }).map((association) => {
-    return association[1];
-  });
-}
-__name(belongsToManyAssociations, "belongsToManyAssociations");
-function modelAssociationByKey(instance, key) {
-  return modelAssociations(instance)[key];
-}
-__name(modelAssociationByKey, "modelAssociationByKey");
-async function updateModelByValues(instance, values, options) {
-  if (!(options == null ? void 0 : options.sanitized)) {
-    const guard = new import_update_guard.UpdateGuard();
-    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);
-}
-__name(updateModelByValues, "updateModelByValues");
-async function updateThroughTableValue(instance, throughName, throughValues, source, transaction = null) {
-  for (const belongsToMany of belongsToManyAssociations(instance)) {
-    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
-      });
-    }
-  }
-}
-__name(updateThroughTableValue, "updateThroughTableValue");
-async function updateAssociations(instance, values, options = {}) {
-  if (!values) {
-    return;
-  }
-  if (options == null ? void 0 : options.updateAssociationValues) {
-    options.recursive = true;
-  }
-  let newTransaction = false;
-  let transaction = options.transaction;
-  if (!transaction) {
-    newTransaction = true;
-    transaction = await instance.sequelize.transaction();
-  }
-  const keys = Object.keys(values);
-  try {
-    for (const key of Object.keys(modelAssociations(instance))) {
-      if (keys.includes(key)) {
-        await updateAssociation(instance, key, values[key], {
-          ...options,
-          transaction
-        });
-      }
-    }
-    for (const belongsToMany of belongsToManyAssociations(instance)) {
-      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();
-    }
-  } catch (error) {
-    if (newTransaction) {
-      await transaction.rollback();
-    }
-    throw error;
-  }
-}
-__name(updateAssociations, "updateAssociations");
-function isReverseAssociationPair(a, b) {
-  const typeSet = /* @__PURE__ */ 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.target.name === targetAssoc.source.name && sourceAssoc.foreignKey === targetAssoc.foreignKey && sourceAssoc.sourceKey === targetAssoc.targetKey;
-  }
-  return false;
-}
-__name(isReverseAssociationPair, "isReverseAssociationPair");
-async function updateAssociation(instance, key, value, options = {}) {
-  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);
-  }
-}
-__name(updateAssociation, "updateAssociation");
-async function updateSingleAssociation(model, key, value, options = {}) {
-  const association = modelAssociationByKey(model, key);
-  if (!association) {
-    return false;
-  }
-  if (!["undefined", "string", "number", "object"].includes(typeof value)) {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    throw new Error(`The value of '${key}' cannot be in array format`);
-  }
-  const { recursive, context, updateAssociationValues = [], transaction } = options;
-  const keys = getKeysByPrefix(updateAssociationValues, key);
-  const setAccessor = association.accessors.set;
-  const removeAssociation = /* @__PURE__ */ __name(async () => {
-    await model[setAccessor](null, { transaction });
-    model.setDataValue(key, null);
-    return true;
-  }, "removeAssociation");
-  if (isUndefinedOrNull(value)) {
-    return await removeAssociation();
-  }
-  if (association.associationType === "HasOne" && !model.get(association.sourceKeyAttribute)) {
-    throw new Error(`The source key ${association.sourceKeyAttribute} is not set in ${model.constructor.name}`);
-  }
-  const checkBelongsToForeignKeyValue = /* @__PURE__ */ __name(() => {
-    if (association.associationType === "BelongsTo" && !model.get(association.foreignKey)) {
-      throw new Error(
-        // @ts-ignore
-        `The target key ${association.targetKey} is not set in ${association.target.name}`
-      );
-    }
-  }, "checkBelongsToForeignKeyValue");
-  if (isStringOrNumber(value)) {
-    await model[setAccessor](value, { context, transaction });
-    return true;
-  }
-  if (value instanceof import_model.Model) {
-    await model[setAccessor](value, { context, transaction });
-    model.setDataValue(key, value);
-    return true;
-  }
-  const createAccessor = association.accessors.create;
-  let dataKey;
-  let M;
-  if (association.associationType === "BelongsTo") {
-    M = association.target;
-    dataKey = association.targetKey;
-  } else {
-    M = association.target;
-    dataKey = M.primaryKeyAttribute;
-  }
-  if (isStringOrNumber(value[dataKey])) {
-    const instance2 = await M.findOne({
-      where: {
-        [dataKey]: value[dataKey]
-      },
-      transaction
-    });
-    if (instance2) {
-      await model[setAccessor](instance2, { context, transaction });
-      if (!recursive) {
-        return;
-      }
-      if (updateAssociationValues.includes(key)) {
-        await instance2.update(value, { ...options, transaction });
-      }
-      await updateAssociations(instance2, value, {
-        ...options,
-        transaction,
-        associationContext: association,
-        updateAssociationValues: keys
-      });
-      model.setDataValue(key, instance2);
-      return true;
-    }
-  }
-  const instance = await model[createAccessor](value, { context, transaction });
-  await updateAssociations(instance, value, {
-    ...options,
-    transaction,
-    associationContext: association,
-    updateAssociationValues: keys
-  });
-  model.setDataValue(key, instance);
-  if (association.targetKey) {
-    model.setDataValue(association.foreignKey, instance[dataKey]);
-  }
-  checkBelongsToForeignKeyValue();
-}
-__name(updateSingleAssociation, "updateSingleAssociation");
-async function updateMultipleAssociation(model, key, value, options = {}) {
-  var _a, _b;
-  const association = modelAssociationByKey(model, key);
-  if (!association) {
-    return false;
-  }
-  if (!["undefined", "string", "number", "object"].includes(typeof value)) {
-    return false;
-  }
-  const { recursive, context, updateAssociationValues = [], transaction } = options;
-  const keys = getKeysByPrefix(updateAssociationValues, key);
-  const setAccessor = association.accessors.set;
-  const createAccessor = association.accessors.create;
-  if (isUndefinedOrNull(value)) {
-    await model[setAccessor](null, { transaction, context, individualHooks: true });
-    model.setDataValue(key, null);
-    return;
-  }
-  if (association.associationType === "HasMany" && !model.get(association.sourceKeyAttribute)) {
-    throw new Error(`The source key ${association.sourceKeyAttribute} is not set in ${model.constructor.name}`);
-  }
-  if (isStringOrNumber(value)) {
-    await model[setAccessor](value, { transaction, context, individualHooks: true });
-    return;
-  }
-  value = import_lodash.default.castArray(value);
-  const setItems = [];
-  const objectItems = [];
-  for (const item of value) {
-    if (isUndefinedOrNull(item)) {
-      continue;
-    }
-    if (isStringOrNumber(item)) {
-      setItems.push(item);
-    } else if (item instanceof import_model.Model) {
-      setItems.push(item);
-    } else if (item.sequelize) {
-      setItems.push(item);
-    } else if (typeof item === "object") {
-      const targetKey2 = association.targetKey || "id";
-      if (item[targetKey2]) {
-        const attributes = {
-          [targetKey2]: item[targetKey2]
-        };
-        const instance = association.target.build(attributes, { isNewRecord: false });
-        setItems.push(instance);
-      }
-      objectItems.push(item);
-    }
-  }
-  await model[setAccessor](setItems, { transaction, context, individualHooks: true });
-  const newItems = [];
-  const pk = association.target.primaryKeyAttribute;
-  const tmpKey = (_a = association["options"]) == null ? void 0 : _a["targetKey"];
-  let targetKey = pk;
-  const db = model.constructor["database"];
-  if (tmpKey !== pk) {
-    const targetKeyFieldOptions = (_b = db.getFieldByPath(`${association.target.name}.${tmpKey}`)) == null ? void 0 : _b.options;
-    if (targetKeyFieldOptions == null ? void 0 : targetKeyFieldOptions.unique) {
-      targetKey = tmpKey;
-    }
-  }
-  for (const item of objectItems) {
-    const through = association.through ? association.through.model.name : null;
-    const accessorOptions = {
-      context,
-      transaction
-    };
-    const throughValue = item[through];
-    if (throughValue) {
-      accessorOptions["through"] = throughValue;
-    }
-    if (pk !== targetKey && !isUndefinedOrNull(item[pk]) && isUndefinedOrNull(item[targetKey])) {
-      throw new Error(`${targetKey} field value is empty`);
-    }
-    if (isUndefinedOrNull(item[targetKey])) {
-      const instance = await model[createAccessor](item, accessorOptions);
-      await updateAssociations(instance, item, {
-        ...options,
-        transaction,
-        associationContext: association,
-        updateAssociationValues: keys
-      });
-      newItems.push(instance);
-    } else {
-      const where = {
-        [targetKey]: item[targetKey]
-      };
-      let instance = await association.target.findOne({
-        where,
-        transaction
-      });
-      if (!instance) {
-        instance = await model[createAccessor](item, accessorOptions);
-        await updateAssociations(instance, item, {
-          ...options,
-          transaction,
-          associationContext: association,
-          updateAssociationValues: keys
-        });
-        newItems.push(instance);
-        continue;
-      }
-      const addAccessor = association.accessors.add;
-      await model[addAccessor](instance, accessorOptions);
-      if (!recursive) {
-        continue;
-      }
-      if (updateAssociationValues.includes(key)) {
-        await instance.update(item, { ...options, transaction });
-      }
-      await updateAssociations(instance, item, {
-        ...options,
-        transaction,
-        associationContext: association,
-        updateAssociationValues: keys
-      });
-      newItems.push(instance);
-    }
-  }
-  for (const newItem of newItems) {
-    const existIndexInSetItems = setItems.findIndex((setItem) => setItem[targetKey] === newItem[targetKey]);
-    if (existIndexInSetItems !== -1) {
-      setItems[existIndexInSetItems] = newItem;
-    } else {
-      setItems.push(newItem);
-    }
-  }
-  model.setDataValue(key, setItems);
-}
-__name(updateMultipleAssociation, "updateMultipleAssociation");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  belongsToManyAssociations,
-  modelAssociationByKey,
-  modelAssociations,
-  updateAssociation,
-  updateAssociations,
-  updateModelByValues,
-  updateMultipleAssociation,
-  updateSingleAssociation,
-  updateThroughTableValue
-});

package/lib/update-guard.d.ts

@@ -1,36 +0,0 @@
-/**
- * This file is part of the NocoBase (R) project.
- * Copyright (c) 2020-2024 NocoBase Co., Ltd.
- * Authors: NocoBase Team.
- *
- * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
- * For more information, please refer to: https://www.nocobase.com/agreement.
- */
-import { ModelStatic } from 'sequelize';
-import { AssociationKeysToBeUpdate, BlackList, WhiteList } from './repository';
-type UpdateValueItem = string | number | UpdateValues;
-type UpdateValues = {
-    [key: string]: UpdateValueItem | Array<UpdateValueItem>;
-};
-type UpdateAction = 'create' | 'update';
-export declare class UpdateGuard {
-    model: ModelStatic<any>;
-    action: UpdateAction;
-    underscored: boolean;
-    private associationKeysToBeUpdate;
-    private blackList;
-    private whiteList;
-    static fromOptions(model: any, options: any): UpdateGuard;
-    setAction(action: UpdateAction): void;
-    setModel(model: ModelStatic<any>): void;
-    setAssociationKeysToBeUpdate(associationKeysToBeUpdate: AssociationKeysToBeUpdate): void;
-    setWhiteList(whiteList: WhiteList): void;
-    setBlackList(blackList: BlackList): void;
-    checkValues(values: any): void;
-    /**
-     * Sanitize values by whitelist blacklist
-     * @param values
-     */
-    sanitize(values: UpdateValues): {};
-}
-export {};

package/lib/update-guard.js

@@ -1,212 +0,0 @@
-/**
- * This file is part of the NocoBase (R) project.
- * Copyright (c) 2020-2024 NocoBase Co., Ltd.
- * Authors: NocoBase Team.
- *
- * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
- * For more information, please refer to: https://www.nocobase.com/agreement.
- */
-
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var update_guard_exports = {};
-__export(update_guard_exports, {
-  UpdateGuard: () => UpdateGuard
-});
-module.exports = __toCommonJS(update_guard_exports);
-var import_lodash = __toESM(require("lodash"));
-var import_model = require("./model");
-const _UpdateGuard = class _UpdateGuard {
-  model;
-  action;
-  underscored;
-  associationKeysToBeUpdate;
-  blackList;
-  whiteList;
-  static fromOptions(model, options) {
-    const guard = new _UpdateGuard();
-    guard.setModel(model);
-    guard.setWhiteList(options.whitelist);
-    guard.setBlackList(options.blacklist);
-    guard.setAction(import_lodash.default.get(options, "action", "update"));
-    guard.setAssociationKeysToBeUpdate(options.updateAssociationValues);
-    if (options.underscored) {
-      guard.underscored = options.underscored;
-    }
-    return guard;
-  }
-  setAction(action) {
-    this.action = action;
-  }
-  setModel(model) {
-    this.model = model;
-  }
-  setAssociationKeysToBeUpdate(associationKeysToBeUpdate) {
-    if (this.action == "create") {
-      this.associationKeysToBeUpdate = Object.keys(this.model.associations);
-    } else {
-      this.associationKeysToBeUpdate = associationKeysToBeUpdate;
-    }
-  }
-  setWhiteList(whiteList) {
-    this.whiteList = whiteList;
-  }
-  setBlackList(blackList) {
-    this.blackList = blackList;
-  }
-  checkValues(values) {
-    const dfs = /* @__PURE__ */ __name((values2, model) => {
-      const associations = model.associations;
-      const belongsToManyThroughNames = [];
-      const associationValueKeys = Object.keys(associations).filter((key) => {
-        return Object.keys(values2).includes(key);
-      });
-      const belongsToManyValueKeys = associationValueKeys.filter((key) => {
-        return associations[key].associationType === "BelongsToMany";
-      });
-      const hasManyValueKeys = associationValueKeys.filter((key) => {
-        return associations[key].associationType === "HasMany";
-      });
-      for (const belongsToManyKey of belongsToManyValueKeys) {
-        const association = associations[belongsToManyKey];
-        const through = association.through.model;
-        belongsToManyThroughNames.push(through.name);
-      }
-      for (const hasManyKey of hasManyValueKeys) {
-        const association = associations[hasManyKey];
-        if (belongsToManyThroughNames.includes(association.target.name)) {
-          throw new Error(
-            `HasMany association ${hasManyKey} cannot be used with BelongsToMany association ${association.target.name} with same through model`
-          );
-        }
-      }
-    }, "dfs");
-    dfs(values, this.model);
-  }
-  /**
-   * Sanitize values by whitelist blacklist
-   * @param values
-   */
-  sanitize(values) {
-    if (values === null || values === void 0) {
-      return values;
-    }
-    values = import_lodash.default.clone(values);
-    if (!this.model) {
-      throw new Error("please set model first");
-    }
-    this.checkValues(values);
-    const associations = this.model.associations;
-    const associationsValues = import_lodash.default.pick(values, Object.keys(associations));
-    const listOfAssociation = /* @__PURE__ */ __name((list, association) => {
-      if (list) {
-        list = list.filter((whiteListKey) => whiteListKey.startsWith(`${association}.`)).map((whiteListKey) => whiteListKey.replace(`${association}.`, ""));
-        if (list.length == 0) {
-          return void 0;
-        }
-        return list;
-      }
-      return void 0;
-    }, "listOfAssociation");
-    Object.keys(associationsValues).forEach((association) => {
-      let associationValues = associationsValues[association];
-      const associationObj = associations[association];
-      const filterAssociationToBeUpdate = /* @__PURE__ */ __name((value) => {
-        var _a;
-        if (value === null) {
-          return value;
-        }
-        const associationKeysToBeUpdate = this.associationKeysToBeUpdate || [];
-        if (associationKeysToBeUpdate.includes(association)) {
-          return value;
-        }
-        const associationKeyName = ((_a = associationObj == null ? void 0 : associationObj["options"]) == null ? void 0 : _a.targetKey) ? associationObj["options"].targetKey : associationObj.target.primaryKeyAttribute;
-        if (value[associationKeyName]) {
-          return import_lodash.default.pick(value, [associationKeyName, ...Object.keys(associationObj.target.associations)]);
-        }
-        return value;
-      }, "filterAssociationToBeUpdate");
-      const sanitizeValue = /* @__PURE__ */ __name((value) => {
-        const associationUpdateGuard = new _UpdateGuard();
-        associationUpdateGuard.setModel(associations[association].target);
-        ["whiteList", "blackList", "associationKeysToBeUpdate"].forEach((optionKey) => {
-          associationUpdateGuard[`set${import_lodash.default.upperFirst(optionKey)}`](listOfAssociation(this[optionKey], association));
-        });
-        return associationUpdateGuard.sanitize(filterAssociationToBeUpdate(value));
-      }, "sanitizeValue");
-      if (Array.isArray(associationValues)) {
-        associationValues = associationValues.map((value) => {
-          if (value === void 0 || value === null || typeof value == "string" || typeof value == "number") {
-            return value;
-          } else {
-            return sanitizeValue(value);
-          }
-        });
-      } else if (typeof associationValues === "object" && associationValues !== null) {
-        associationValues = sanitizeValue(associationValues);
-      }
-      values[association] = associationValues;
-      if (associationObj.associationType === "BelongsTo") {
-        if (typeof associationValues === "object" && associationValues !== null) {
-          if (associationValues[associationObj.targetKey] != null) {
-            values[associationObj.foreignKey] = associationValues[associationObj.targetKey];
-          }
-        } else {
-          values[associationObj.foreignKey] = associationValues;
-        }
-      }
-    });
-    if (values instanceof import_model.Model) {
-      return values;
-    }
-    let valuesKeys = Object.keys(values || {});
-    if (this.whiteList) {
-      valuesKeys = valuesKeys.filter((valueKey) => {
-        return this.whiteList.findIndex((whiteKey) => {
-          const keyPaths = whiteKey.split(".");
-          return keyPaths[0] === valueKey;
-        }) !== -1;
-      });
-    }
-    if (this.blackList) {
-      valuesKeys = valuesKeys.filter((valueKey) => !this.blackList.includes(valueKey));
-    }
-    const result = valuesKeys.reduce((obj, key) => {
-      import_lodash.default.set(obj, key, values[key]);
-      return obj;
-    }, {});
-    return result;
-  }
-};
-__name(_UpdateGuard, "UpdateGuard");
-let UpdateGuard = _UpdateGuard;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  UpdateGuard
-});

package/lib/utils.d.ts

@@ -1,15 +0,0 @@
-/**
- * This file is part of the NocoBase (R) project.
- * Copyright (c) 2020-2024 NocoBase Co., Ltd.
- * Authors: NocoBase Team.
- *
- * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
- * For more information, please refer to: https://www.nocobase.com/agreement.
- */
-import Database from './database';
-export declare function md5(value: string): string;
-export declare function checkIdentifier(value: string): void;
-export declare function getTableName(collectionName: string, options: any): any;
-export declare function snakeCase(name: string): any;
-export declare function patchSequelizeQueryInterface(db: Database): void;
-export declare function percent2float(value: string): number;