@availity/yup 4.1.0 → 5.0.0

package/src/dateRange.ts

@@ -0,0 +1,215 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+import { MixedSchema, ValidationError } from 'yup';
+import moment, { Moment, unitOfTime } from 'moment';
+import get from 'lodash/get';
+import merge from 'lodash/merge';
+
+const defaultOptions = {
+  startKey: 'startDate',
+  endKey: 'endDate',
+  format: 'MM/DD/YYYY',
+};
+
+const formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD'];
+
+export default class DateRangeSchema extends MixedSchema<DateRange> {
+  startKey: string;
+
+  endKey: string;
+
+  format: string;
+
+  constructor(options?: Options) {
+    super({
+      type: 'dateRange',
+    });
+
+    const { startKey, endKey, format } = merge({}, defaultOptions, options);
+
+    // Assign them here so we can use in schema.transform
+    this.startKey = startKey;
+    this.endKey = endKey;
+    this.format = format;
+
+    this.withMutation((schema) => {
+      schema.transform(function mutate(value) {
+        const start = get(value, startKey);
+        const end = get(value, endKey);
+
+        return {
+          startDate: start ? schema.getValidDate(start) : start,
+          endDate: end ? schema.getValidDate(end) : end,
+          supportedFormats: [schema.format, ...formats],
+        };
+      });
+    });
+  }
+
+  // Convert the string to a moment object
+  getValidDate(value: string | Date | Moment) {
+    return moment(value, [this.format, ...formats], true);
+  }
+
+  distance({
+    min: { value: minValue, units: minUnits = 'day', errorMessage: minErrorMessage } = { value: 0 },
+    max: { value: maxValue, units: maxUnits = 'day', errorMessage: maxErrorMessage } = { value: 0 },
+  }: DistanceOptions = {}) {
+    return this.test({
+      name: 'distance',
+      exclusive: true,
+      test({ endDate, startDate } = {}) {
+        // check if we have min or max set and if both dates are present
+        if ((!minValue && !maxValue) || !startDate || !endDate) return true;
+
+        // if we have a max then check distance between end and start
+        if (maxValue && endDate.isAfter(startDate.add(maxValue, maxUnits), 'day')) {
+          return new ValidationError(
+            maxErrorMessage ||
+              `The end date must be within ${maxValue} ${maxUnits}${maxValue > 1 ? 's' : ''} of the start date`,
+            {
+              startDate,
+              endDate,
+            },
+            this.path
+          );
+        }
+
+        // if we have a min the check distance between end and start
+        if (minValue && endDate.isBefore(startDate.add(minValue, minUnits), 'day')) {
+          return new ValidationError(
+            minErrorMessage ||
+              `The end date must be greater than ${minValue} ${minUnits}${minValue > 1 ? 's' : ''} of the start date`,
+            { startDate, endDate },
+            this.path
+          );
+        }
+
+        return true;
+      },
+    });
+  }
+
+  min(min: string, message?: string) {
+    // it works for date, but not daterange. maybe that can tell us more about what is going on
+    // const minDate = this.getValidDate(min);
+
+    return this.test({
+      message: message || (({ min }: { min: string }) => `Date Range must start on or after ${min}`),
+      name: 'min',
+      exclusive: true,
+      params: { min },
+      test({ startDate, supportedFormats } = {}) {
+        // return true when no startDate or min set
+        if (!startDate || !min) return true;
+
+        // otherwise check if min is correct format and is after given startDate
+        const minDate = moment(min, supportedFormats, true);
+
+        return minDate.isValid() && minDate.isSameOrBefore(startDate);
+      },
+    });
+  }
+
+  max(max: string, message?: string) {
+    // const maxDate = this.getValidDate(max);
+
+    return this.test({
+      message: message || (({ max }: { max: string }) => `Date Range must end on or before ${max}`),
+      name: 'max',
+      exclusive: true,
+      params: { max },
+      test({ endDate, supportedFormats } = {}) {
+        // return true when no endDate given or max set
+        if (!endDate || !max) return true;
+
+        // otherwise check if max is correct format and is after given endDate
+        const maxDate = moment(max, supportedFormats, true);
+
+        return maxDate.isValid() && maxDate.isSameOrAfter(endDate);
+      },
+    });
+  }
+
+  between(min: string, max: string, message?: string) {
+    // const minDate = this.getValidDate(min);
+    // const maxDate = this.getValidDate(max);
+
+    return this.test({
+      message:
+        message || (({ min, max }: { min: string; max: string }) => `Date Range must be between ${min} and ${max}`),
+      name: 'between',
+      exclusive: true,
+      params: { min, max },
+      test({ startDate, endDate, supportedFormats } = {}) {
+        if (!startDate || !endDate || !min || !max) return true;
+
+        const minDate = moment(min, supportedFormats, true);
+        const maxDate = moment(max, supportedFormats, true);
+
+        return (
+          maxDate.isValid() && minDate.isValid() && maxDate.isSameOrAfter(endDate) && minDate.isSameOrBefore(startDate)
+        );
+      },
+    });
+  }
+
+  isRequired(isRequired = true, msg?: string) {
+    return this.test({
+      name: 'isRequired',
+      exclusive: true,
+      message: msg || 'This field is required.',
+      test({ startDate, endDate } = {}) {
+        return !isRequired || !!(startDate && endDate);
+      },
+    });
+  }
+
+  typeError({ message }: { message: string }) {
+    return this.test({
+      name: 'typeError',
+      exclusive: true,
+      test({ startDate, endDate } = {}) {
+        // Set to `any` to pass to ValidationErrors. Docs state string[] is accepted,
+        // but types do not allow string[]
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const errors: any = [];
+
+        if ((!startDate || !endDate) && (startDate || endDate)) {
+          errors.push(message || 'Start and End Date are required.');
+        }
+
+        if (startDate && endDate && !startDate.isSameOrBefore(endDate)) {
+          errors.push('Start date must come before end date.');
+        }
+
+        if (startDate && !startDate.isValid()) {
+          errors.push('Start Date is invalid.');
+        }
+
+        if (endDate && !endDate.isValid()) {
+          errors.push('End Date is invalid.');
+        }
+
+        return errors.length > 0 ? new ValidationError(errors, { startDate, endDate }, this.path) : true;
+      },
+    });
+  }
+
+  _typeCheck(range: { startDate?: Moment; endDate?: Moment } = {}): range is DateRange {
+    const { startDate, endDate } = range;
+
+    return !!startDate && !!endDate && startDate.isValid() && endDate.isValid();
+  }
+}
+
+type Options = { startKey?: string; endKey?: string; format?: string };
+type DateRange = { startDate?: Moment; endDate?: Moment; supportedFormats?: string[] };
+type DistanceValue = {
+  value: number;
+  // unitOfTime namespace is provided by moment library
+  units?: unitOfTime.DurationConstructor;
+  errorMessage?: string;
+};
+type DistanceOptions = { min?: DistanceValue; max?: DistanceValue };
+
+export const dateRange = (opts?: Options): DateRangeSchema => new DateRangeSchema(opts);

package/src/index.ts

@@ -0,0 +1,67 @@
+import { addMethod, array, number, object, string } from 'yup';
+import { AnyObject, Maybe, Optionals } from 'yup/lib/types';
+import BaseSchema, { AnySchema } from 'yup/lib/schema';
+import { Asserts, TypeOf } from 'yup/lib/util/types';
+import { AssertsShape, ObjectShape, TypeOfShape } from 'yup/lib/object';
+import Lazy from 'yup/lib/Lazy';
+
+import { avDate } from './date';
+import { dateRange } from './dateRange';
+import isRequired from './isRequired';
+import npi from './npi';
+import phone from './phone';
+
+export { avDate, dateRange };
+
+addMethod(array, 'isRequired', isRequired);
+addMethod(number, 'isRequired', isRequired);
+addMethod(object, 'isRequired', isRequired);
+addMethod(string, 'isRequired', isRequired);
+
+addMethod(number, 'npi', npi);
+addMethod(string, 'npi', npi);
+
+addMethod(number, 'phone', phone);
+addMethod(string, 'phone', phone);
+
+// Add definitions to yup
+declare module 'yup' {
+  interface StringSchema<
+    TType extends Maybe<string> = string | undefined,
+    TContext extends AnyObject = AnyObject,
+    TOut extends TType = TType
+  > extends BaseSchema<TType, TContext, TOut> {
+    isRequired(required?: boolean, errorMessage?: string): StringSchema<TType, TContext>;
+    npi(errorMessage?: string): StringSchema<TType, TContext>;
+    phone(errorMessage?: string): StringSchema<TType, TContext>;
+  }
+
+  interface NumberSchema<
+    TType extends Maybe<number> = number | undefined,
+    TContext extends AnyObject = AnyObject,
+    TOut extends TType = TType
+  > extends BaseSchema<TType, TContext, TOut> {
+    isRequired(required?: boolean, errorMessage?: string): NumberSchema<TType, TContext, TOut>;
+    npi(errorMessage?: string): NumberSchema<TType, TContext, TOut>;
+    phone(errorMessage?: string): NumberSchema<TType, TContext, TOut>;
+  }
+
+  interface ArraySchema<
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    T extends AnySchema | Lazy<any, any>,
+    C extends AnyObject = AnyObject,
+    TIn extends Maybe<TypeOf<T>[]> = TypeOf<T>[] | undefined,
+    TOut extends Maybe<Asserts<T>[]> = Asserts<T>[] | Optionals<TIn>
+  > extends BaseSchema<TIn, C, TOut> {
+    isRequired(required?: boolean, errorMessage?: string): ArraySchema<T, C, TIn, TOut>;
+  }
+
+  interface ObjectSchema<
+    TShape extends ObjectShape,
+    TContext extends AnyObject = AnyObject,
+    TIn extends Maybe<TypeOfShape<TShape>> = TypeOfShape<TShape>,
+    TOut extends Maybe<AssertsShape<TShape>> = AssertsShape<TShape> | Optionals<TIn>
+  > extends BaseSchema<TIn, TContext, TOut> {
+    isRequired(required?: boolean, errorMessage?: string): ObjectSchema<TShape, TContext, TIn, TOut>;
+  }
+}

package/src/isRequired.ts

@@ -0,0 +1,26 @@
+import { BaseSchema } from 'yup';
+
+function isRequired<Schema extends BaseSchema>(this: Schema, isRequired = true, msg?: string): Schema {
+  return this.test({
+    name: 'isRequired',
+    exclusive: true,
+    message: msg || 'This field is required.',
+    test(value) {
+      if (isRequired) {
+        // array and string have custom logic
+        if (this.schema.type === 'array') {
+          return Array.isArray(value) ? value.length > 0 : value !== undefined;
+        }
+        if (this.schema.type === 'string') {
+          return value !== undefined && value !== '';
+        }
+        // default logic for all other types
+        return value !== undefined;
+      }
+
+      return true;
+    },
+  });
+}
+
+export default isRequired;

package/src/{npi.js → npi.ts}

@@ -1,6 +1,8 @@
+import { BaseSchema } from 'yup';
+
 const INTEGER_REGEX = /^\d*$/;
 
-function npi(msg) {
+function npi<Schema extends BaseSchema>(this: Schema, msg?: string): Schema {
   return this.test({
     name: 'npi',
     exclusive: true,
@@ -10,10 +12,12 @@ function npi(msg) {
 
       value += '';
 
+      // is it a number and 10 digits long
       if (!INTEGER_REGEX.test(value) || value.length !== 10) {
         return false;
       }
 
+      // is the first digit 1-4
       const firstDigit = value.charAt(0);
       if (['1', '2', '3', '4'].indexOf(firstDigit) < 0) {
         return false;

package/src/{phone.js → phone.ts}

@@ -1,6 +1,8 @@
+import { BaseSchema } from 'yup';
+
 const NANP_REGEXP = /^(\+?1[\s.-]?)?\(?[2-9]\d{2}[\s).-]?\s?[2-9]\d{2}[\s.-]?\d{4}$/;
 
-function phone(msg) {
+function phone<Schema extends BaseSchema>(this: Schema, msg: string): Schema {
   return this.test({
     name: 'phone',
     exclusive: true,

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["."],
+  "exclude": ["dist", "build", "node_modules"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"],
+    "allowJs": true
+  },
+  "include": ["**/*.test.ts", "**/*.spec.ts", "**/*.d.ts"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016-present Availity, LLC
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/lib/date.js

@@ -1,172 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-
-require("core-js/modules/es.function.name.js");
-
-require("core-js/modules/es.array.concat.js");
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
-
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-
-var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
-
-var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
-
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
-
-var _yup = require("yup");
-
-var _moment = _interopRequireDefault(require("moment"));
-
-var defaultOpts = {
-  format: 'MM/DD/YYYY'
-};
-var formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD', 'MM-DD-YYYY'];
-
-var AvDateSchema = /*#__PURE__*/function (_MixedSchema) {
-  (0, _inherits2["default"])(AvDateSchema, _MixedSchema);
-
-  var _super = (0, _createSuper2["default"])(AvDateSchema);
-
-  function AvDateSchema() {
-    var _thisSuper, _this;
-
-    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultOpts,
-        _ref$format = _ref.format,
-        format = _ref$format === void 0 ? 'MM/DD/YYYY' : _ref$format;
-
-    (0, _classCallCheck2["default"])(this, AvDateSchema);
-    _this = _super.call(this, {
-      type: 'avDate'
-    });
-    _this.format = format;
-    _this.getValidDate = _this.getValidDate.bind((0, _assertThisInitialized2["default"])(_this));
-
-    _this.withMutation(function (schema) {
-      if (!schema.tests.some(function (test) {
-        var _test$OPTIONS;
-
-        return (test === null || test === void 0 ? void 0 : (_test$OPTIONS = test.OPTIONS) === null || _test$OPTIONS === void 0 ? void 0 : _test$OPTIONS.name) === 'typeError';
-      })) {
-        (0, _get2["default"])((_thisSuper = (0, _assertThisInitialized2["default"])(_this), (0, _getPrototypeOf2["default"])(AvDateSchema.prototype)), "typeError", _thisSuper).call(_thisSuper, 'Date is invalid.');
-      }
-
-      schema.transform(function mutate(value) {
-        return schema.getValidDate(value);
-      });
-    });
-
-    return _this;
-  }
-
-  (0, _createClass2["default"])(AvDateSchema, [{
-    key: "_typeCheck",
-    value: function _typeCheck(value) {
-      // So as long as the passed in value is defined, moment._i will contain a string value to validate.
-      // If user enters a date and then removes it, should not show a typeError
-      // Note: this does not prevent other tests, like isRequired, from showing messages
-      // If user has touched a required field, required error message should still show
-      return value.isValid() || value._i === '';
-    }
-  }, {
-    key: "getValidDate",
-    value: function getValidDate(value) {
-      return (0, _moment["default"])(value, [this.format].concat(formats), true);
-    }
-  }, {
-    key: "min",
-    value: function min(_min, message) {
-      var minDate = this.getValidDate(_min);
-      return this.test({
-        message: message || "Date must be ".concat(minDate.format(this.format), " or later."),
-        name: 'min',
-        exclusive: true,
-        params: {
-          min: _min
-        },
-        test: function test(value) {
-          if (!_min || !minDate.isValid()) {
-            return true;
-          }
-
-          return value === null || minDate.isSameOrBefore(value, 'MM/DD/YYYY');
-        }
-      });
-    }
-  }, {
-    key: "max",
-    value: function max(_max, message) {
-      var maxDate = this.getValidDate(_max);
-      return this.test({
-        message: message || "Date must be ".concat(maxDate.format(this.format), " or earlier."),
-        name: 'max',
-        exclusive: true,
-        params: {
-          max: _max
-        },
-        test: function test(value) {
-          if (!_max || !maxDate.isValid()) {
-            return true;
-          }
-
-          return value === null || maxDate.isSameOrAfter(value);
-        }
-      });
-    }
-  }, {
-    key: "isRequired",
-    value: function isRequired() {
-      var _isRequired = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-
-      var msg = arguments.length > 1 ? arguments[1] : undefined;
-      return this.test({
-        name: 'isRequired',
-        exclusive: true,
-        message: msg || 'This field is required.',
-        test: function test(value) {
-          if (!_isRequired) {
-            return true;
-          }
-
-          return value !== undefined;
-        }
-      });
-    }
-  }, {
-    key: "between",
-    value: function between(min, max, msg) {
-      var inclusivity = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '()';
-      var minDate = this.getValidDate(min);
-      var maxDate = this.getValidDate(max); // Can't use arrow function because we rely on 'this' referencing yup's internals
-
-      return this.test({
-        name: 'between',
-        exclusive: true,
-        // Validation errors don't stack
-        // NOTE: Intentional use of single quotes - yup will handle the string interpolation
-        message: msg || "Date must be between ".concat(minDate.format(this.format), " and ").concat(maxDate.format(this.format), "."),
-        test: function test(value) {
-          if (!value || !min || !max || !minDate.isValid() || !maxDate.isValid()) {
-            return true;
-          }
-
-          return value.isBetween(minDate, maxDate, undefined, inclusivity);
-        }
-      });
-    }
-  }]);
-  return AvDateSchema;
-}(_yup.MixedSchema);
-
-exports["default"] = AvDateSchema;