dtable-utils 0.0.1

package/lib/validate/filter.js

@@ -0,0 +1,458 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _typeof = require('@babel/runtime/helpers/typeof');
+var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
+var _createClass = require('@babel/runtime/helpers/createClass');
+var cellType = require('../constants/cell-type.js');
+var column = require('../constants/column.js');
+var formula = require('../constants/formula.js');
+var index = require('../constants/filter/index.js');
+var common = require('../column/common.js');
+var date = require('../column/date.js');
+var filterPredicate = require('../constants/filter/filter-predicate.js');
+var filterModifier = require('../constants/filter/filter-modifier.js');
+var filterColumnOptions = require('../constants/filter/filter-column-options.js');
+var filterIsWithin = require('../constants/filter/filter-is-within.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_typeof);
+var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
+var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
+
+var TERM_TYPE_MAP = {
+  NUMBER: 'number',
+  STRING: 'string',
+  BOOLEAN: 'boolean',
+  ARRAY: 'array'
+};
+var TEXT_COLUMN_TYPES = [cellType.CellType.TEXT, cellType.CellType.STRING];
+var CHECK_EMPTY_PREDICATES = [filterPredicate.FILTER_PREDICATE_TYPE.EMPTY, filterPredicate.FILTER_PREDICATE_TYPE.NOT_EMPTY];
+var PREDICATES_REQUIRE_ARRAY_TERM = [filterPredicate.FILTER_PREDICATE_TYPE.IS_ANY_OF, filterPredicate.FILTER_PREDICATE_TYPE.IS_NONE_OF];
+var DATE_MODIFIERS_REQUIRE_TERM = [filterModifier.FILTER_TERM_MODIFIER_TYPE.NUMBER_OF_DAYS_AGO, filterModifier.FILTER_TERM_MODIFIER_TYPE.NUMBER_OF_DAYS_FROM_NOW, filterModifier.FILTER_TERM_MODIFIER_TYPE.THE_NEXT_NUMBERS_OF_DAYS, filterModifier.FILTER_TERM_MODIFIER_TYPE.THE_PAST_NUMBERS_OF_DAYS, filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE];
+var MODIFIERS_REQUIRE_NUMERIC_TERM = [filterModifier.FILTER_TERM_MODIFIER_TYPE.NUMBER_OF_DAYS_AGO, filterModifier.FILTER_TERM_MODIFIER_TYPE.NUMBER_OF_DAYS_FROM_NOW, filterModifier.FILTER_TERM_MODIFIER_TYPE.THE_NEXT_NUMBERS_OF_DAYS, filterModifier.FILTER_TERM_MODIFIER_TYPE.THE_PAST_NUMBERS_OF_DAYS];
+var ValidateFilter = /*#__PURE__*/function () {
+  function ValidateFilter() {
+    _classCallCheck__default["default"](this, ValidateFilter);
+  }
+  _createClass__default["default"](ValidateFilter, null, [{
+    key: "validate",
+    value:
+    /**
+     * Check filter is valid. The error_message from returns will be null if the filter is valid.
+     * 1.incomplete filter which should be ignored
+     *  - column_key: required
+     *  - filter_predicate: required
+     *  - filter_term_modifier: determined by the column to filter with
+     *  - filter_term: determined by filter_predicate / the column to filter with
+     * 2.illegal filter
+     *  - column missing: cannot find the column to filter
+     *  - column not support: the column to filter is not support
+     *  - mismatch: filter_predicate, filter_term_modifier mismatch
+     *  - wrong data type: filter_term with wrong data type
+     *  @param {object} filter e.g. { column_key, filter_term, ... }
+     *  @param {array} columns e.g. [{ key, name, ... }, ...]
+     *  @param {bool} isValidTerm No longer to validate filter term if false. default as false
+     *  @returns { error_message }, object
+     */
+    function validate(filter, columns) {
+      var isValidTerm = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      var column_key = filter.column_key,
+        filter_predicate = filter.filter_predicate,
+        filter_term_modifier = filter.filter_term_modifier,
+        filter_term = filter.filter_term;
+      var _this$validateColumn = this.validateColumn(column_key, columns),
+        column_error_message = _this$validateColumn.error_message;
+      if (column_error_message) {
+        return {
+          error_message: column_error_message
+        };
+      }
+      var filterColumn = columns.find(function (column) {
+        return column.key === column_key;
+      });
+      var _this$validatePredica = this.validatePredicate(filter_predicate, filterColumn),
+        predicate_error_message = _this$validatePredica.error_message;
+      if (predicate_error_message) {
+        return {
+          error_message: predicate_error_message
+        };
+      }
+      if (this.isFilterOnlyWithPredicate(filter_predicate, filterColumn)) {
+        return {
+          error_message: null
+        };
+      }
+      var _this$validateModifie = this.validateModifier(filter_term_modifier, filter_predicate, filterColumn),
+        modifier_error_message = _this$validateModifie.error_message;
+      if (modifier_error_message) {
+        return {
+          error_message: modifier_error_message
+        };
+      }
+      if (this.isFilterOnlyWithModifier(filter_term_modifier, filterColumn)) {
+        return {
+          error_message: null
+        };
+      }
+      if (isValidTerm) {
+        var _this$validateTerm = this.validateTerm(filter_term, filter_predicate, filter_term_modifier, filterColumn),
+          term_error_message = _this$validateTerm.error_message;
+        if (term_error_message) {
+          return {
+            error_message: term_error_message
+          };
+        }
+      }
+      return {
+        error_message: null
+      };
+    }
+  }, {
+    key: "validateColumn",
+    value: function validateColumn(column_key, columns) {
+      if (!column_key) {
+        return {
+          error_message: index.FILTER_ERR_MSG.INCOMPLETE_FILTER
+        };
+      }
+      var filterColumn = columns.find(function (column) {
+        return column.key === column_key;
+      });
+      if (!filterColumn) {
+        return {
+          error_message: index.FILTER_ERR_MSG.COLUMN_MISSING
+        };
+      }
+      if (!this.isValidColumnType(filterColumn)) {
+        return {
+          error_message: index.FILTER_ERR_MSG.COLUMN_NOT_SUPPORTED
+        };
+      }
+      return {
+        error_message: null
+      };
+    }
+
+    /**
+     * the column to filter must be available
+     */
+  }, {
+    key: "validatePredicate",
+    value: function validatePredicate(predicate, filterColumn) {
+      if (!predicate) {
+        return {
+          error_message: index.FILTER_ERR_MSG.INCOMPLETE_FILTER
+        };
+      }
+      var columnType = filterColumn.type,
+        data = filterColumn.data;
+      var filterConfigs = filterColumnOptions.FILTER_COLUMN_OPTIONS[columnType];
+      var predicateList = filterConfigs.filterPredicateList;
+      if (formula.FORMULA_COLUMN_TYPES_MAP[columnType] || columnType === cellType.CellType.LINK) {
+        var result_type = data.result_type;
+        if (result_type === formula.FORMULA_RESULT_TYPE.ARRAY) {
+          return this.validatePredicateWithArrayType(predicate, filterColumn);
+        }
+        return this.validatePredicate(predicate, {
+          type: result_type
+        });
+      }
+      if (!predicateList.includes(predicate)) {
+        return {
+          error_message: index.FILTER_ERR_MSG.UNMATCHED_PREDICATE
+        };
+      }
+      return {
+        error_message: null
+      };
+    }
+  }, {
+    key: "validatePredicateWithArrayType",
+    value: function validatePredicateWithArrayType(predicate, filterColumn) {
+      var data = filterColumn.data;
+      var array_type = data.array_type;
+      if (array_type === cellType.CellType.SINGLE_SELECT) {
+        return this.validatePredicate(predicate, {
+          type: cellType.CellType.MULTIPLE_SELECT
+        });
+      }
+      if (column.COLLABORATOR_COLUMN_TYPES.includes(array_type)) {
+        return this.validatePredicate(predicate, {
+          type: cellType.CellType.COLLABORATOR
+        });
+      }
+      return this.validatePredicate(predicate, {
+        type: array_type
+      });
+    }
+
+    /**
+     * filter predicate must be available.
+     * filterColumn the column to filter must be available
+     */
+  }, {
+    key: "isFilterOnlyWithPredicate",
+    value: function isFilterOnlyWithPredicate(predicate, filterColumn) {
+      if (CHECK_EMPTY_PREDICATES.includes(predicate)) {
+        return true;
+      }
+      var columnType = filterColumn.type,
+        data = filterColumn.data;
+      if (formula.FORMULA_COLUMN_TYPES_MAP[columnType] || columnType === cellType.CellType.LINK) {
+        var result_type = data.result_type,
+          array_type = data.array_type;
+        if (result_type === formula.FORMULA_RESULT_TYPE.ARRAY) {
+          return this.isFilterOnlyWithPredicate(predicate, {
+            type: array_type
+          });
+        }
+        return this.isFilterOnlyWithPredicate(predicate, {
+          type: result_type
+        });
+      }
+      var IS_CURRENT_USER_ID = filterPredicate.FILTER_PREDICATE_TYPE.IS_CURRENT_USER_ID,
+        INCLUDE_ME = filterPredicate.FILTER_PREDICATE_TYPE.INCLUDE_ME;
+      if (predicate === IS_CURRENT_USER_ID && TEXT_COLUMN_TYPES.includes(columnType)) {
+        return true;
+      }
+      if (predicate === INCLUDE_ME && column.COLLABORATOR_COLUMN_TYPES.includes(columnType)) {
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * filter predicate must be available.
+     * the column to filter must be available
+     */
+  }, {
+    key: "validateModifier",
+    value: function validateModifier(modifier, predicate, filterColumn) {
+      if (!date.isDateColumn(filterColumn)) {
+        return {
+          error_message: null
+        };
+      }
+      if (!modifier) {
+        return {
+          error_message: index.FILTER_ERR_MSG.INCOMPLETE_FILTER
+        };
+      }
+      if (predicate === filterPredicate.FILTER_PREDICATE_TYPE.IS_WITHIN) {
+        if (filterIsWithin.filterTermModifierIsWithin.includes(modifier)) {
+          return {
+            error_message: null
+          };
+        }
+      } else if (filterIsWithin.filterTermModifierNotWithin.includes(modifier)) {
+        return {
+          error_message: null
+        };
+      }
+      return {
+        error_message: index.FILTER_ERR_MSG.UNMATCHED_MODIFIER
+      };
+    }
+
+    /**
+     * filter predicate must be available.
+     * filter modifier must be available.
+     * the column to filter must be available
+     */
+  }, {
+    key: "isFilterOnlyWithModifier",
+    value: function isFilterOnlyWithModifier(modifier, filterColumn) {
+      if (date.isDateColumn(filterColumn)) {
+        return !DATE_MODIFIERS_REQUIRE_TERM.includes(modifier);
+      }
+      return false;
+    }
+  }, {
+    key: "validateTerm",
+    value: function validateTerm(term, predicate, modifier, filterColumn) {
+      if (this.isTermMissing(term)) {
+        return {
+          error_message: index.FILTER_ERR_MSG.INCOMPLETE_FILTER
+        };
+      }
+      if (!this.isValidTerm(term, predicate, modifier, filterColumn)) {
+        return {
+          error_message: index.FILTER_ERR_MSG.INVALID_TERM
+        };
+      }
+      return {
+        error_message: null
+      };
+    }
+  }, {
+    key: "isTermMissing",
+    value: function isTermMissing(term) {
+      return !term && term !== 0 && term !== false || Array.isArray(term) && term.length === 0;
+    }
+  }, {
+    key: "isValidTerm",
+    value: function isValidTerm(term, predicate, modifier, filterColumn) {
+      switch (filterColumn.type) {
+        case cellType.CellType.TEXT:
+        case cellType.CellType.GEOLOCATION:
+        case cellType.CellType.AUTO_NUMBER:
+        case cellType.CellType.EMAIL:
+        case cellType.CellType.URL:
+        case cellType.CellType.STRING:
+          {
+            return this.isValidTermType(term, TERM_TYPE_MAP.STRING);
+          }
+        case cellType.CellType.SINGLE_SELECT:
+          {
+            var options = common.getColumnOptions(filterColumn);
+            if (PREDICATES_REQUIRE_ARRAY_TERM.includes(predicate)) {
+              if (!this.isValidTermType(term, TERM_TYPE_MAP.ARRAY)) {
+                return false;
+              }
+
+              // contains deleted option(s)
+              return this.isValidSelectedOptions(term, options);
+            }
+            if (!this.isValidTermType(term, TERM_TYPE_MAP.STRING)) {
+              return false;
+            }
+
+            // invalid filter_term if selected option is deleted
+            return !!options.find(function (option) {
+              return term === option.id;
+            });
+          }
+        case cellType.CellType.NUMBER:
+        case cellType.CellType.DURATION:
+        case cellType.CellType.RATE:
+          {
+            return this.isValidTermType(term, TERM_TYPE_MAP.NUMBER);
+          }
+        case cellType.CellType.CHECKBOX:
+        case cellType.CellType.BOOL:
+          {
+            return this.isValidTermType(term, TERM_TYPE_MAP.BOOLEAN);
+          }
+        case cellType.CellType.COLLABORATOR:
+        case cellType.CellType.CREATOR:
+        case cellType.CellType.LAST_MODIFIER:
+          {
+            return this.isValidTermType(term, TERM_TYPE_MAP.ARRAY);
+          }
+        case cellType.CellType.MULTIPLE_SELECT:
+          {
+            if (!this.isValidTermType(term, TERM_TYPE_MAP.ARRAY)) {
+              return false;
+            }
+
+            // contains deleted option(s)
+            var _options = common.getColumnOptions(filterColumn);
+            return this.isValidSelectedOptions(term, _options);
+          }
+        case cellType.CellType.DATE:
+        case cellType.CellType.CTIME:
+        case cellType.CellType.MTIME:
+          {
+            if (MODIFIERS_REQUIRE_NUMERIC_TERM.includes(modifier)) {
+              return this.isValidTermType(term, TERM_TYPE_MAP.NUMBER);
+            }
+            return this.isValidTermType(term, TERM_TYPE_MAP.STRING);
+          }
+        case cellType.CellType.FORMULA:
+        case cellType.CellType.LINK_FORMULA:
+          {
+            var data = filterColumn.data;
+            var result_type = data.result_type;
+            if (result_type === formula.FORMULA_RESULT_TYPE.ARRAY) {
+              return this.isValidTermWithArrayType(term, predicate, modifier, filterColumn);
+            }
+            return this.isValidTerm(term, predicate, modifier, {
+              type: result_type
+            });
+          }
+        case cellType.CellType.LINK:
+          {
+            return this.isValidTermWithArrayType(term, predicate, modifier, filterColumn);
+          }
+        default:
+          {
+            return false;
+          }
+      }
+    }
+  }, {
+    key: "isValidTermType",
+    value: function isValidTermType(term, type) {
+      if (type === TERM_TYPE_MAP.ARRAY) {
+        return Array.isArray(term) && term.length > 0;
+      }
+      if (type === cellType.CellType.NUMBER) {
+        // is a number or a number string
+        // eslint-disable-next-line
+        return _typeof__default["default"](term) === type || !isNaN(Number(term));
+      }
+      // eslint-disable-next-line
+      return _typeof__default["default"](term) === type;
+    }
+  }, {
+    key: "isValidTermWithArrayType",
+    value: function isValidTermWithArrayType(term, predicate, modifier, filterColumn) {
+      var data = filterColumn.data;
+      var array_type = data.array_type,
+        array_data = data.array_data;
+      if (array_type === cellType.CellType.SINGLE_SELECT) {
+        return this.isValidTerm(term, predicate, modifier, {
+          type: cellType.CellType.MULTIPLE_SELECT,
+          data: array_data
+        });
+      }
+      if (column.COLLABORATOR_COLUMN_TYPES.includes(array_type)) {
+        return this.isValidTerm(term, predicate, modifier, {
+          type: cellType.CellType.COLLABORATOR
+        });
+      }
+      return this.isValidTerm(term, predicate, modifier, {
+        type: array_type,
+        data: array_data
+      });
+    }
+  }, {
+    key: "isValidColumnType",
+    value: function isValidColumnType(filterColumn) {
+      var columnType = filterColumn.type,
+        data = filterColumn.data;
+      if (formula.FORMULA_COLUMN_TYPES_MAP[columnType] || columnType === cellType.CellType.LINK) {
+        if (!data) {
+          return false;
+        }
+        var result_type = data.result_type,
+          array_type = data.array_type;
+        if (result_type === formula.FORMULA_RESULT_TYPE.ARRAY) {
+          return this.isValidColumnType({
+            type: array_type
+          });
+        }
+        return this.isValidColumnType({
+          type: result_type
+        });
+      }
+      // eslint-disable-next-line
+      return filterColumnOptions.FILTER_COLUMN_OPTIONS.hasOwnProperty(columnType);
+    }
+  }, {
+    key: "isValidSelectedOptions",
+    value: function isValidSelectedOptions(selectedOptionIds, options) {
+      var validSelectedOptions = options.filter(function (option) {
+        return selectedOptionIds.includes(option.id);
+      });
+      return selectedOptionIds.length === validSelectedOptions.length;
+    }
+  }]);
+  return ValidateFilter;
+}();
+
+exports.DATE_MODIFIERS_REQUIRE_TERM = DATE_MODIFIERS_REQUIRE_TERM;
+exports.ValidateFilter = ValidateFilter;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "dtable-utils",
+  "version": "0.0.1",
+  "description": "dtable common utils",
+  "main": "./lib/index.js",
+  "module": "./es/index.js",
+  "private": false,
+  "scripts": {
+    "test": "jest -c --watchAll",
+    "eslint": "eslint ./src/**",
+    "build": "rm -rf dist lib es && rollup -c",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "utils",
+    "JavaScript"
+  ],
+  "author": "SeaTable",
+  "files": [
+    "dist",
+    "lib",
+    "es",
+    "package.json"
+  ],
+  "dependencies": {
+    "dayjs": "1.10.7"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.22.5",
+    "@babel/plugin-transform-runtime": "^7.22.5",
+    "@babel/preset-env": "^7.22.5",
+    "@rollup/plugin-babel": "^6.0.3",
+    "@rollup/plugin-commonjs": "^25.0.2",
+    "@rollup/plugin-eslint": "^9.0.4",
+    "@rollup/plugin-json": "^6.0.0",
+    "@rollup/plugin-node-resolve": "^15.1.0",
+    "@rollup/plugin-terser": "^0.4.3",
+    "babel-jest": "^29.5.0",
+    "eslint": "^8.43.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "jest": "^29.5.0",
+    "rollup": "2.79.1"
+  }
+}