@availity/yup 3.2.1 → 4.2.0

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

@@ -1,20 +1,18 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 import { MixedSchema } from 'yup';
-import moment from 'moment';
-
-const defaultOpts = {
-  format: 'MM/DD/YYYY',
-};
+import moment, { Moment } from 'moment';
 
 const formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD', 'MM-DD-YYYY'];
 
-export default class AvDateSchema extends MixedSchema {
-  constructor({ format = 'MM/DD/YYYY' } = defaultOpts) {
+export default class AvDateSchema extends MixedSchema<Moment> {
+  format: string;
+
+  constructor({ format = 'MM/DD/YYYY' }: Options = {}) {
     super({
       type: 'avDate',
     });
 
     this.format = format;
-    this.getValidDate = this.getValidDate.bind(this);
 
     this.withMutation((schema) => {
       if (!schema.tests.some((test) => test?.OPTIONS?.name === 'typeError')) {
@@ -26,7 +24,7 @@ export default class AvDateSchema extends MixedSchema {
     });
   }
 
-  _typeCheck(value) {
+  _typeCheck(value: Moment & { _i: string }): value is Moment & { _i: string } {
     // 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
@@ -34,11 +32,11 @@ export default class AvDateSchema extends MixedSchema {
     return value.isValid() || value._i === '';
   }
 
-  getValidDate(value) {
+  getValidDate(value: string | Date | Moment) {
     return moment(value, [this.format, ...formats], true);
   }
 
-  min(min, message) {
+  min(min: string, message?: string) {
     const minDate = this.getValidDate(min);
 
     return this.test({
@@ -50,12 +48,12 @@ export default class AvDateSchema extends MixedSchema {
         if (!min || !minDate.isValid()) {
           return true;
         }
-        return value === null || minDate.isSameOrBefore(value, 'MM/DD/YYYY');
+        return value === null || minDate.isSameOrBefore(value);
       },
     });
   }
 
-  max(max, message) {
+  max(max: string, message?: string) {
     const maxDate = this.getValidDate(max);
 
     return this.test({
@@ -72,7 +70,7 @@ export default class AvDateSchema extends MixedSchema {
     });
   }
 
-  isRequired(isRequired = true, msg) {
+  isRequired(isRequired = true, msg?: string) {
     return this.test({
       name: 'isRequired',
       exclusive: true,
@@ -87,9 +85,8 @@ export default class AvDateSchema extends MixedSchema {
     });
   }
 
-  between(min, max, msg, inclusivity = '()') {
+  between(min: string, max: string, msg?: string, inclusivity: Inclusivity = '()') {
     const minDate = this.getValidDate(min);
-
     const maxDate = this.getValidDate(max);
 
     // Can't use arrow function because we rely on 'this' referencing yup's internals
@@ -108,3 +105,8 @@ export default class AvDateSchema extends MixedSchema {
     });
   }
 }
+
+export type Inclusivity = '()' | '[)' | '(]' | '[]';
+type Options = { format?: string };
+
+export const avDate = (opts?: Options): AvDateSchema => new AvDateSchema(opts);

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.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.build.json",
+  "compilerOptions": {
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["**/*.test.ts"]
+}

package/src/dateRange.js

@@ -1,184 +0,0 @@
-import { MixedSchema, ValidationError } from 'yup';
-import moment from 'moment';
-import get from 'lodash/get';
-import merge from 'lodash/merge';
-
-const defaultOptions = {
-  startKey: 'startDate',
-  endKey: 'endDate',
-  format: 'MM/DD/YYYY',
-};
-
-const defaultValue = {};
-
-const formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD'];
-
-export default class DateRangeSchema extends MixedSchema {
-  constructor(options) {
-    super({
-      type: 'dateRange',
-    });
-
-    const { startKey, endKey, format } = merge({}, defaultOptions, options);
-
-    this.startKey = startKey;
-    this.endKey = endKey;
-    this.format = format;
-    this.getValidDate = this.getValidDate.bind(this);
-
-    this.withMutation((schema) => {
-      schema.transform(function mutate(value) {
-        const start = get(value, startKey);
-        const end = get(value, endKey);
-
-        let startDate;
-        let endDate;
-        if (start) {
-          startDate = schema.getValidDate(start);
-        }
-
-        if (end) {
-          endDate = schema.getValidDate(end);
-        }
-        return { startDate, endDate };
-      });
-    });
-  }
-
-  getValidDate(value) {
-    return moment(value, [this.format, ...formats], true);
-  }
-
-  distance({
-    min: { value: minValue, units: minUnits = 'day', errorMessage: minErrorMessage } = {},
-    max: { value: maxValue, units: maxUnits = 'day', errorMessage: maxErrorMessage } = {},
-  } = defaultValue) {
-    return this.test({
-      name: 'distance',
-      exclusive: true,
-      test({ endDate, startDate } = defaultValue) {
-        if ((!minValue && !maxValue) || !startDate || !endDate) return true;
-
-        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 (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, message) {
-    const { format } = this;
-
-    const minDate = this.getValidDate(min);
-    return this.test({
-      message: message || `Date Range must start on or after ${minDate.format(format)}`,
-      name: 'min',
-      exclusive: true,
-      params: { min },
-      test({ startDate } = defaultValue) {
-        if (!startDate || !min) {
-          return true;
-        }
-        return minDate.isValid() && minDate.isSameOrBefore(startDate);
-      },
-    });
-  }
-
-  max(max, message) {
-    const { format } = this;
-
-    const maxDate = this.getValidDate(max);
-
-    return this.test({
-      message: message || `Date Range must end on or before ${maxDate.format(format)}`,
-      name: 'max',
-      exclusive: true,
-      params: { max },
-      test({ endDate } = defaultValue) {
-        if (!endDate || !max) return true;
-        return maxDate.isValid() && maxDate.isSameOrAfter(endDate);
-      },
-    });
-  }
-
-  between(min, max, message) {
-    const { format } = this;
-
-    const minDate = this.getValidDate(min);
-    const maxDate = this.getValidDate(max);
-
-    return this.test({
-      message: message || `Date Range must be between ${minDate.format(format)} and ${maxDate.format(format)}`,
-      name: 'between',
-      exclusive: true,
-      params: { min, max },
-      test({ startDate, endDate } = defaultValue) {
-        if (!startDate || !endDate || !min || !max) return true;
-        return (
-          maxDate.isValid() && minDate.isValid() && maxDate.isSameOrAfter(endDate) && minDate.isSameOrBefore(startDate)
-        );
-      },
-    });
-  }
-
-  isRequired(isRequired = true, msg) {
-    return this.test({
-      name: 'isRequired',
-      exclusive: true,
-      message: msg || 'This field is required.',
-      test({ startDate, endDate } = defaultValue) {
-        return !isRequired || (startDate && endDate);
-      },
-    });
-  }
-
-  typeError() {
-    return this.test({
-      name: 'typeError',
-      exclusive: true,
-      test({ startDate, endDate } = defaultValue) {
-        const errors = [];
-
-        if ((!startDate || !endDate) && (startDate || endDate)) {
-          errors.push('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({ startDate, endDate } = defaultValue) {
-    return startDate && endDate && startDate.isValid() && endDate.isValid();
-  }
-}

package/src/isRequired.js

@@ -1,22 +0,0 @@
-function isRequired(isRequired = true, msg) {
-  return this.test({
-    name: 'isRequired',
-    exclusive: true,
-    message: msg || 'This field is required.',
-    test(value) {
-      if (isRequired) {
-        if (typeof value === 'number') {
-          return value !== undefined;
-        }
-        if (Array.isArray(value)) {
-          return value.length > 0;
-        }
-        // String ( If you want to check for null add nullable )
-        return value !== undefined && value !== '';
-      }
-      return true;
-    },
-  });
-}
-
-export default isRequired;

package/types/date.d.ts

@@ -1,21 +0,0 @@
-import * as yup from 'yup';
-
-declare module 'yup' {
-  interface DateOpts {
-    format?: string | 'MM/DD/YYYY';
-  }
-
-  interface AvDateSchema<T extends string | null | undefined = string> extends MixedSchema<T> {
-    min(date: string, errorMessage?: string): DateRangeSchema<T>;
-    max(date: string, errorMessage?: string): DateRangeSchema<T>;
-    between(minDate: string, maxDate: string, errorMessage?: string): AvDateSchema<T>;
-    isRequired(required?: boolean, errorMessage?: string): AvDateSchema<T>;
-  }
-
-  export interface AvDateSchemaConstructor {
-    (opts: DateOpts): AvDateSchema;
-    new (opts: DateOpts): AvDateSchema;
-  }
-
-  export const avDate: AvDateSchemaConstructor;
-}