@tachybase/database 0.23.8

package/lib/update-associations.js

@@ -0,0 +1,405 @@
+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]) {
+        setItems.push(item[targetKey2]);
+      }
+      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 (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[association.target.primaryKeyAttribute], 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);
+    }
+  }
+  model.setDataValue(key, setItems.concat(newItems));
+}
+__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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,202 @@
+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) => {
+        if (value === null) {
+          return value;
+        }
+        const associationKeysToBeUpdate = this.associationKeysToBeUpdate || [];
+        if (associationKeysToBeUpdate.includes(association)) {
+          return value;
+        }
+        const associationKeyName = associationObj.associationType == "BelongsTo" || associationObj.associationType == "HasOne" ? associationObj.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

@@ -0,0 +1,7 @@
+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;