dce-reactkit 3.4.0-beta.8 → 3.4.0

package/src/helpers/validators/validateString.test.ts

@@ -0,0 +1,175 @@
+// Import helpers
+import genCommaList from '../genCommaList';
+
+// Import types
+import ValidationResult from './shared/types/ValidationResult';
+
+// Import constants
+import { INVALID_STRING_ERRORS, INVALID_REGEX_ERROR } from './shared/constants/ERROR_MESSAGES';
+
+// Import function
+import validateString from './validateString';
+
+/*------------------------------------------------------------------------*/
+/* ---------------------------- Valid Tests --------------------------- */
+/*------------------------------------------------------------------------*/
+
+const validStrings: string[] = [
+  'users',
+  'username',
+  'MyValidString',
+  'HereisAnotherValidString',
+  'WoahAnotherValidStringIsHere',
+];
+
+const validReqs: {
+  // whitespace is removed from input before checking and returning
+  ignoreWhitespace?: boolean,
+  // input length must be at least minLen
+  minLen?: number,
+  // input length must be at most maxLen
+  maxLen?: number,
+  // input must only contain letters
+  lettersOnly?: boolean,
+  // input must only contain numbers
+  numbersOnly?: boolean,
+  // input must match given regExp
+  regexTest?: RegExp,
+  // description of regExp test, used to customize error messages
+  regexDescription?: string,
+}[] = [
+  {
+  },
+  {
+    minLen: 5,
+  },
+  {
+    minLen: 5,
+    maxLen: 30,
+  },
+  {
+    minLen: 5,
+    maxLen: 30,
+    lettersOnly: true,
+  },
+  {
+    minLen: 5,
+    maxLen: 30,
+    lettersOnly: true,
+    numbersOnly: false,
+  },
+  {
+    minLen: 5,
+    maxLen: 30,
+    lettersOnly: true,
+    numbersOnly: false,
+    ignoreWhitespace: false,
+  },
+];
+
+test(
+  'Returns true for a given valid string.',
+  async () => {
+    validStrings.forEach((validString) => {
+      validReqs.forEach((validReq) => {
+        const validResponse: ValidationResult<string> = {
+          isValid: true,
+          cleanedValue: validString,
+        };
+
+        expect(validateString(validString, validReq)).toStrictEqual(validResponse);
+      });
+    });
+
+    const validString = 'A string with whitespace!';
+
+    const validResponse: ValidationResult<string> = {
+      isValid: true,
+      cleanedValue: 'Astringwithwhitespace!',
+    };
+
+    const validOpt = {
+      maxLen: 22,
+      ignoreWhitespace: true,
+    };
+
+    expect(validateString(validString, validOpt)).toStrictEqual(validResponse);
+  },
+);
+
+/*------------------------------------------------------------------------*/
+/* ---------------------------- Invalid Tests --------------------------- */
+/*------------------------------------------------------------------------*/
+
+const invalidStrings: {
+  input: string,
+  reqs: {
+    // whitespace is removed from input before checking and returning
+    ignoreWhitespace?: boolean,
+    // input length must be at least minLen
+    minLen?: number,
+    // input length must be at most maxLen
+    maxLen?: number,
+    // input must only contain letters
+    lettersOnly?: boolean,
+    // input must only contain numbers
+    numbersOnly?: boolean,
+    // input must match given regExp
+    regexTest?: RegExp,
+    // description of regExp test, used to customize error messages
+    regexDescription?: string,
+  },
+  error: string[]
+}[] = [
+  {
+    input: 'ûšër',
+    reqs: {
+      minLen: 5,
+      lettersOnly: true,
+    },
+    error: [INVALID_STRING_ERRORS.MIN_LEN(5)],
+  },
+  {
+    input: '123456789',
+    reqs: {
+      minLen: 10,
+      maxLen: 5,
+      lettersOnly: true,
+    },
+    error: [INVALID_STRING_ERRORS.MIN_LEN(10), INVALID_STRING_ERRORS.MAX_LEN(5), INVALID_STRING_ERRORS.LETTERS_ONLY],
+  },
+  {
+    input: 'String with non-letters!!',
+    reqs: {
+      lettersOnly: true,
+      numbersOnly: true,
+      ignoreWhitespace: true,
+    },
+    error: [INVALID_STRING_ERRORS.LETTERS_ONLY, INVALID_STRING_ERRORS.NUMBERS_ONLY],
+  },
+  {
+    input: '12345678',
+    reqs: {
+      lettersOnly: true,
+      regexTest: /^\s*(?:\+?(\d{1,3}))?[-. (]*(\d{3})[-. )]*(\d{3})[-. ]*(\d{4})(?: *x(\d+))?\s*$/,
+      regexDescription: 'should be a phone number',
+    },
+    error: [INVALID_STRING_ERRORS.LETTERS_ONLY, `${INVALID_REGEX_ERROR}: should be a phone number`],
+  },
+];
+
+test(
+  'Returns false for a given invalid string.',
+  async () => {
+    invalidStrings.forEach((triple) => {
+      const invalidResponse: ValidationResult<string> = {
+        isValid: false,
+        errorMessage: `${INVALID_STRING_ERRORS.MESSAGE_INTRO}${genCommaList(triple.error)}.`,
+      };
+
+      console.log(invalidResponse.errorMessage);
+
+      expect(validateString(triple.input, triple.reqs)).toStrictEqual(invalidResponse);
+    });
+  },
+);

package/src/helpers/validators/validateString.ts

@@ -0,0 +1,171 @@
+// Import helpers
+import validateRegex from './shared/helpers/validateRegex';
+import genCommaList from '../genCommaList';
+
+// Import constants
+import { INVALID_STRING_ERRORS } from './shared/constants/ERROR_MESSAGES';
+
+// Import types
+import ValidationResult from './shared/types/ValidationResult';
+
+/*------------------------------------------------------------------------*/
+/* ------------------------------ Constants ----------------------------- */
+/*------------------------------------------------------------------------*/
+
+// define minimum and maximum range for lowercase ASCII chars
+const LOWERCASE_MIN = 65;
+const LOWERCASE_MAX = 90;
+
+// define minimum and maximum range for uppercase ASCII chars
+const UPPERCASE_MIN = 97;
+const UPPERCASE_MAX = 122;
+
+// define minimum and maximum range for ASCII digits
+const DIGIT_MIN = 48;
+const DIGIT_MAX = 57;
+
+/*------------------------------------------------------------------------*/
+/* ---------------------------- Main Function --------------------------- */
+/*------------------------------------------------------------------------*/
+
+/**
+ * Determines whether a given input string is considered valid based on
+ *   the provided requirements.
+ * @author Austen Money
+ * @param input input string
+ * @param opts options for validation
+ * @returns whether input is considered valid according to reqs - if
+ *   valid, returns a cleaned version of input; if invalid, returns
+ *   a string containing error messages describing which requirements
+ *   were not met.
+ */
+const validateString = (
+  input: string,
+  opts: {
+    // whitespace is removed from input before checking and returning
+    ignoreWhitespace?: boolean,
+    // input length must be at least minLen
+    minLen?: number,
+    // input length must be at most maxLen
+    maxLen?: number,
+    // input must only contain letters
+    // (future TODO: add option for passing in an array of permitted chars)
+    lettersOnly?: boolean,
+    // input must only contain numbers
+    numbersOnly?: boolean,
+    // input must match given regExp
+    regexTest?: RegExp,
+    // description of regExp test, used to customize error messages
+    regexDescription?: string,
+  },
+): ValidationResult<string> => {
+  // stores all invalid input errors
+  const errorMessages: string[] = [];
+
+  // contains version of input that will be returned
+  let cleanedValue: string = input;
+
+  // remove whitespace if required
+  if (opts.ignoreWhitespace) {
+    cleanedValue = input.replace(/\s+/g, '');
+  }
+
+  // apply max char requirement
+  if (opts.minLen) {
+    if (cleanedValue.length < opts.minLen) {
+      errorMessages.push(INVALID_STRING_ERRORS.MIN_LEN(opts.minLen));
+    }
+  }
+
+  // apply max char requirement
+  if (opts.maxLen) {
+    if (cleanedValue.length > opts.maxLen) {
+      errorMessages.push(INVALID_STRING_ERRORS.MAX_LEN(opts.maxLen));
+    }
+  }
+
+  // apply alphabetical requirement
+  if (opts.lettersOnly) {
+    // remove diacritics
+    cleanedValue = cleanedValue.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+
+    const containsNonLetters = (
+      cleanedValue
+        // split into characters
+        .split('')
+        // convert into character codes
+        .map((curr) => {
+          return curr.charCodeAt(0);
+        })
+        // check for non-letters
+        .some((currCode) => {
+          return (
+            !(currCode >= LOWERCASE_MIN && currCode <= LOWERCASE_MAX)
+            && !(currCode >= UPPERCASE_MIN && currCode <= UPPERCASE_MAX)
+          );
+        })
+    );
+
+    if (containsNonLetters) {
+      errorMessages.push(INVALID_STRING_ERRORS.LETTERS_ONLY);
+    }
+  }
+
+  // apply numerical requirement
+  if (opts.numbersOnly) {
+    const containsNonNumbers = (
+      cleanedValue
+        // split into characters
+        .split('')
+        // convert into character codes
+        .map((curr) => {
+          return curr.charCodeAt(0);
+        })
+        // check for non-numbers
+        .some((currCode) => {
+          return (
+            !(currCode >= DIGIT_MIN && currCode <= DIGIT_MAX)
+          );
+        })
+    );
+
+    if (containsNonNumbers) {
+      errorMessages.push(INVALID_STRING_ERRORS.NUMBERS_ONLY);
+    }
+  }
+
+  // apply regex requirement
+  if (opts.regexTest) {
+    const regex = opts.regexTest;
+
+    // validate and create customized error message if description is provided
+    const result = validateRegex({
+      input: cleanedValue,
+      regex,
+      regexDescription: opts.regexDescription,
+    });
+
+    // if string did not pass regex validation, add error message
+    if (result.isValid === false) {
+      errorMessages.push(result.errorMessage);
+    }
+  }
+
+  // combine all error messages into one string to return
+  const errorMessage = `${INVALID_STRING_ERRORS.MESSAGE_INTRO}${genCommaList(errorMessages)}.`;
+
+  return (
+    // if no error messages, string is valid; if not, it is invalid
+    errorMessages.length === 0
+      ? {
+        isValid: true,
+        cleanedValue,
+      }
+      : {
+        isValid: false,
+        errorMessage,
+      }
+  );
+};
+
+export default validateString;

package/src/index.ts

@@ -17,7 +17,7 @@ import ItemPicker from './components/ItemPicker';
 import LogReviewer from './components/LogReviewer';
 import IntelliTable from './components/IntelliTable';
 import CSVDownloadButton from './components/CSVDownloadButton';
-import DBEntryManagerPanel from './components/DBEntryManagerPanel';
+
 // Import errors
 import ErrorWithCode from './errors/ErrorWithCode';
 
@@ -63,8 +63,11 @@ import canReviewLogs from './helpers/canReviewLogs';
 import isMobileOrTablet from './helpers/isMobileOrTablet';
 import extractProp from './helpers/extractProp';
 import compareArraysByProp from './helpers/compareArraysByProp';
-import getLocalTimeInfo from './helpers/getLocalTimeInfo';
-import addDBEditorEndpoints from './helpers/addDBEditorEndpoints';
+import genCommaList from './helpers/genCommaList';
+import validateEmail from './helpers/validators/validateEmail';
+import validatePhoneNumber from './helpers/validators/validatePhoneNumber';
+import validateString from './helpers/validators/validateString';
+import getLocalTimeInfo from './helpers/getLocalTimeInfo';  
 
 // Import types
 import ModalButtonType from './types/ModalButtonType';
@@ -84,10 +87,6 @@ import IntelliTableColumn from './types/IntelliTableColumn';
 
 // Component-specific-types
 import PickableItem from './components/ItemPicker/types/PickableItem';
-import DBEntry from './components/DBEntryManagerPanel/types/DBEntry';
-import DBEntryField from './components/DBEntryManagerPanel/types/DBEntryField';
-import DBEntryFieldType from './components/DBEntryManagerPanel/types/DBEntryFieldType';
-
 
 // Export each item
 export {
@@ -110,7 +109,6 @@ export {
   LogReviewer,
   IntelliTable,
   CSVDownloadButton,
-  DBEntryManagerPanel,
   // Global functions
   alert,
   confirm,
@@ -149,6 +147,10 @@ export {
   isMobileOrTablet,
   extractProp,
   compareArraysByProp,
+  genCommaList,
+  validateEmail,
+  validatePhoneNumber,
+  validateString,
   getLocalTimeInfo,
   // Client helpers
   initClient,
@@ -160,7 +162,6 @@ export {
   handleError,
   handleSuccess,
   initLogCollection,
-  addDBEditorEndpoints,
   // Types
   ModalButtonType,
   ModalSize,
@@ -177,9 +178,6 @@ export {
   IntelliTableColumn,
   // Component-specific-types
   PickableItem,
-  DBEntry,
-  DBEntryField,
-  DBEntryFieldType,
   // Server types
   ParamType,
 };

package/tsconfig.json

@@ -15,8 +15,12 @@
     "allowSyntheticDefaultImports": true,
     "emitDeclarationOnly": true
   },
-
   "include": [
     "./src/**/*"
-  ]
+  ],
+  "ts-node": {
+    "compilerOptions": {
+      "module": "commonjs"
+    }
+  },
 }

package/dist/cjs/types/components/DBEntryManagerPanel/AddOrEditDBEntry/CreatableMultiselect.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import DBEntryFieldType from '../types/DBEntryFieldType';
-declare type Props = {
-    type: DBEntryFieldType.StringArray | DBEntryFieldType.NumberArray;
-    values: string[] | number[];
-    onChange: (values: string[] | number[]) => void;
-    disabled?: boolean;
-};
-declare const CreatableMultiselect: React.FC<Props>;
-export default CreatableMultiselect;

package/dist/cjs/types/components/DBEntryManagerPanel/AddOrEditDBEntry/index.d.ts

@@ -1,34 +0,0 @@
-/**
- * Panel for adding a DBEntry to the database
- * @author Yuen Ler Chow
- */
-import React from 'react';
-import DBEntry from '../types/DBEntry';
-import DBEntryField from '../types/DBEntryField';
-declare type Props = {
-    /**
-     * Handler for when the user finishes adding the DBEntry
-     * (if no DBEntry is returned, process was cancelled)
-     * @param DBEntry the DBEntry that was just created
-     */
-    onFinished: (dbEntry?: DBEntry) => void;
-    /**
-     * Function to validate the DBEntry before saving
-     * @param dbEntry
-     */
-    validateEntry?: (dbEntry: DBEntry) => Promise<void>;
-    /**
-     * Function to modify the DBEntry before saving
-     * @param dbEntry
-     * @returns the modified DBEntry
-     */
-    modifyEntry?: (dbEntry: DBEntry) => DBEntry;
-    entryFields: DBEntryField[];
-    dbEntryToEdit?: DBEntry;
-    idPropName: string;
-    itemName: string;
-    saveEndpointPath: string;
-    entries: DBEntry[];
-};
-declare const AddOrEditDBEntry: React.FC<Props>;
-export default AddOrEditDBEntry;

package/dist/cjs/types/components/DBEntryManagerPanel/helpers/generateEndpointPath.d.ts

@@ -1,9 +0,0 @@
-/**
- * Generates the endpoint path for the given collection name
- * @author Yuen Ler Chow
- * @param collectionName the name of the collection
- * @param [adminsOnly] true if the endpoint is for admins only
- * @returns the endpoint path
- */
-declare const generateEndpointPath: (collectionName: string, adminsOnly?: boolean | undefined) => string;
-export default generateEndpointPath;

package/dist/cjs/types/components/DBEntryManagerPanel/index.d.ts

@@ -1,25 +0,0 @@
-/**
- * DB Entry Manager Panel
- * @author Yuen Ler Chow
- */
-import React from 'react';
-import DBEntry from './types/DBEntry';
-import DBEntryField from './types/DBEntryField';
-declare type Props = {
-    entryFields: DBEntryField[];
-    idPropName: string;
-    titlePropName: string;
-    descriptionPropName: string;
-    itemListTitle: string;
-    itemName: string;
-    validateEntry?: (dbEntry: DBEntry) => Promise<void>;
-    modifyEntry?: (dbEntry: DBEntry) => Promise<DBEntry>;
-    disableEdit?: boolean;
-    collectionName: string;
-    adminsOnly?: boolean;
-    filterQuery?: {
-        [k: string]: any;
-    };
-};
-declare const DBEntryManagerPanel: React.FC<Props>;
-export default DBEntryManagerPanel;

package/dist/cjs/types/components/DBEntryManagerPanel/types/DBEntry.d.ts

@@ -1,8 +0,0 @@
-/**
- * Generic type for an object
- * @author Yuen Ler Chow
- */
-declare type DBEntry = {
-    [k: string]: any;
-};
-export default DBEntry;

package/dist/cjs/types/components/DBEntryManagerPanel/types/DBEntryField.d.ts

@@ -1,49 +0,0 @@
-import DBEntryFieldType from './DBEntryFieldType';
-/**
- * A database entry input field
- * @author Yuen Ler Chow
- */
-declare type DBEntryField = ({
-    label: string;
-    objectKey: string;
-    placeholder: string;
-    lockAfterCreation?: boolean;
-    required?: boolean;
-} & ({
-    type: DBEntryFieldType.String;
-    minNumChars?: number;
-    maxNumChars?: number;
-    defaultValue?: string;
-    choices?: {
-        title: string;
-        value: string;
-    }[];
-} | {
-    type: DBEntryFieldType.Number;
-    minNumber?: number;
-    maxNumber?: number;
-    defaultValue?: number;
-} | {
-    type: DBEntryFieldType.StringArray;
-    minNumElements?: number;
-    maxNumElements?: number;
-    defaultValue?: string[];
-    choices?: {
-        title: string;
-        value: string;
-    }[];
-} | {
-    type: DBEntryFieldType.NumberArray;
-    minNumElements?: number;
-    maxNumElements?: number;
-    minNumber?: number;
-    maxNumber?: number;
-    defaultValue?: number[];
-} | {
-    type: DBEntryFieldType.Object;
-    defaultValue?: {
-        [k: string]: any;
-    };
-    subfields: DBEntryField[];
-}));
-export default DBEntryField;

package/dist/cjs/types/components/DBEntryManagerPanel/types/DBEntryFieldType.d.ts

@@ -1,12 +0,0 @@
-/**
- * Options for field types
- * @author Yuen Ler Chow
- */
-declare enum DBEntryFieldType {
-    String = "String",
-    Number = "Number",
-    Object = "Object",
-    StringArray = "StringArray",
-    NumberArray = "NumberArray"
-}
-export default DBEntryFieldType;

package/dist/cjs/types/helpers/addDBEditorEndpoints.d.ts

@@ -1,40 +0,0 @@
-import express from 'express';
-/**
- * Interface for a collection in the database
- * @author Yuen Ler Chow
- */
-interface Collection {
-    /**
-     * Find all items in the collection that match the filter query
-     * @param filterQuery
-     * @returns list of items that match the filter query
-     */
-    find: (filterQuery: any) => Promise<any[]>;
-    /**
-     * Insert an item into the collection
-     * @param item the item to insert
-     */
-    insert: (item: any) => Promise<void>;
-    /**
-     * Delete an item in the collection
-     * @param id the id of the item to delete
-     */
-    delete: (filterQuery: {
-        id: string;
-    }) => Promise<void>;
-}
-/**
- * Add all routes for the DBEditor
- * @author Yuen Ler Chow
- * @param opts object containing all arguments
- * @param opts.app express app to add routes too
- * @param opts.collectionName the name of the collection
- * @param opts.adminsOnly true if the endpoint is for admins only
- */
-declare const addDBEditorEndpoints: (opts: {
-    app: express.Application;
-    collectionName: string;
-    adminsOnly: boolean;
-    collection: Collection;
-}) => void;
-export default addDBEditorEndpoints;

package/dist/esm/types/components/DBEntryManagerPanel/AddOrEditDBEntry/CreatableMultiselect.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import DBEntryFieldType from '../types/DBEntryFieldType';
-declare type Props = {
-    type: DBEntryFieldType.StringArray | DBEntryFieldType.NumberArray;
-    values: string[] | number[];
-    onChange: (values: string[] | number[]) => void;
-    disabled?: boolean;
-};
-declare const CreatableMultiselect: React.FC<Props>;
-export default CreatableMultiselect;

package/dist/esm/types/components/DBEntryManagerPanel/AddOrEditDBEntry/index.d.ts

@@ -1,34 +0,0 @@
-/**
- * Panel for adding a DBEntry to the database
- * @author Yuen Ler Chow
- */
-import React from 'react';
-import DBEntry from '../types/DBEntry';
-import DBEntryField from '../types/DBEntryField';
-declare type Props = {
-    /**
-     * Handler for when the user finishes adding the DBEntry
-     * (if no DBEntry is returned, process was cancelled)
-     * @param DBEntry the DBEntry that was just created
-     */
-    onFinished: (dbEntry?: DBEntry) => void;
-    /**
-     * Function to validate the DBEntry before saving
-     * @param dbEntry
-     */
-    validateEntry?: (dbEntry: DBEntry) => Promise<void>;
-    /**
-     * Function to modify the DBEntry before saving
-     * @param dbEntry
-     * @returns the modified DBEntry
-     */
-    modifyEntry?: (dbEntry: DBEntry) => DBEntry;
-    entryFields: DBEntryField[];
-    dbEntryToEdit?: DBEntry;
-    idPropName: string;
-    itemName: string;
-    saveEndpointPath: string;
-    entries: DBEntry[];
-};
-declare const AddOrEditDBEntry: React.FC<Props>;
-export default AddOrEditDBEntry;

package/dist/esm/types/components/DBEntryManagerPanel/helpers/generateEndpointPath.d.ts

@@ -1,9 +0,0 @@
-/**
- * Generates the endpoint path for the given collection name
- * @author Yuen Ler Chow
- * @param collectionName the name of the collection
- * @param [adminsOnly] true if the endpoint is for admins only
- * @returns the endpoint path
- */
-declare const generateEndpointPath: (collectionName: string, adminsOnly?: boolean | undefined) => string;
-export default generateEndpointPath;