Merge pull request #17 from aniketbiswas21/Date

✨ feat(Parser): Added Date parser and corresponding tests

Author: aniketbiswas21

src/SchemaTypes/Date/checks/allChecks.ts

@@ -0,0 +1,8 @@
+export { typeCheck as type } from "./typeCheck";
+export {
+  greaterThanCheck as greaterThan,
+  greaterThanOrEqualToCheck as greaterThanOrEqual,
+  lessThanCheck as lessThan,
+  lessThanOrEqualToCheck as lessThanOrEqual,
+  equalToCheck as equalTo,
+} from "./valueCheck";

src/SchemaTypes/Date/checks/checksRunner.ts

@@ -0,0 +1,69 @@
+import { DateSchemaConfig } from "../types/DateSchema";
+import {
+  DateSchemaError,
+  DateSchemaErrorEnum as msg,
+} from "../types/DateError";
+import * as check from "./allChecks";
+
+const checkRunner = (
+  x: any,
+  config: DateSchemaConfig,
+  key: string
+): { value: Date; errors: DateSchemaError[] } => {
+  const {
+    greaterThan,
+    greaterThanOrEqualTo,
+    lessThan,
+    lessThanOrEqualTo,
+    equalTo,
+  } = config;
+  const errors: DateSchemaError[] = [];
+
+  //   type check
+  if (!check.type(x)) {
+    errors.push({
+      error: `${key} must be a Date object`,
+      errorType: msg.Type,
+    });
+    return { value: x, errors };
+  }
+
+  //   value check
+  if (greaterThan && !check.greaterThan(x, greaterThan)) {
+    errors.push({
+      error: `${key} must be greater than ${greaterThan}`,
+      errorType: msg.Value,
+    });
+  }
+  if (
+    greaterThanOrEqualTo &&
+    !check.greaterThanOrEqual(x, greaterThanOrEqualTo)
+  ) {
+    errors.push({
+      error: `${key} must be greater than or equal to ${greaterThanOrEqualTo}`,
+      errorType: msg.Value,
+    });
+  }
+  if (lessThan && !check.lessThan(x, lessThan)) {
+    errors.push({
+      error: `${key} must be less than ${lessThan}`,
+      errorType: msg.Value,
+    });
+  }
+  if (lessThanOrEqualTo && !check.lessThanOrEqual(x, lessThanOrEqualTo)) {
+    errors.push({
+      error: `${key} must be less than or equal to ${lessThanOrEqualTo}`,
+      errorType: msg.Value,
+    });
+  }
+  if (equalTo && !check.equalTo(x, equalTo)) {
+    errors.push({
+      error: `${key} must be equal to ${equalTo}`,
+      errorType: msg.Value,
+    });
+  }
+
+  return { value: x, errors };
+};
+
+export default checkRunner;

src/SchemaTypes/Date/checks/typeCheck.ts

@@ -0,0 +1,7 @@
+const typeCheck = (x: any): x is Date => {
+  if (x instanceof Date) return true;
+
+  return false;
+};
+
+export { typeCheck };

src/SchemaTypes/Date/checks/valueCheck.ts

@@ -0,0 +1,37 @@
+const greaterThanCheck = (x: Date, threshold: Date): boolean => {
+  if (x.getTime() > threshold.getTime()) return true;
+
+  return false;
+};
+
+const greaterThanOrEqualToCheck = (x: Date, threshold: Date): boolean => {
+  if (x.getTime() >= threshold.getTime()) return true;
+
+  return false;
+};
+
+const lessThanCheck = (x: Date, threshold: Date): boolean => {
+  if (x.getTime() < threshold.getTime()) return true;
+
+  return false;
+};
+
+const lessThanOrEqualToCheck = (x: Date, threshold: Date): boolean => {
+  if (x.getTime() <= threshold.getTime()) return true;
+
+  return false;
+};
+
+const equalToCheck = (x: Date, threshold: Date): boolean => {
+  if (x.getTime() === threshold.getTime()) return true;
+
+  return false;
+};
+
+export {
+  greaterThanCheck,
+  greaterThanOrEqualToCheck,
+  lessThanCheck,
+  lessThanOrEqualToCheck,
+  equalToCheck,
+};

src/SchemaTypes/Date/class.ts

@@ -0,0 +1,52 @@
+import SchemaType from "../class";
+import checkRunner from "./checks/checksRunner";
+import { DateSchemaConfig } from "./types/DateSchema";
+import { DateSchemaError } from "./types/DateError";
+
+class DateSchema extends SchemaType<Date> {
+  protected override __config: DateSchemaConfig = {};
+
+  public greaterThan = (x: Date): this => {
+    this.__config.greaterThan = x;
+    return this;
+  };
+
+  public greaterThanOrEqualTo = (x: Date): this => {
+    this.__config.greaterThanOrEqualTo = x;
+    return this;
+  };
+
+  public lessThan = (x: Date): this => {
+    this.__config.lessThan = x;
+    return this;
+  };
+
+  public lessThanOrEqualTo = (x: Date): this => {
+    this.__config.lessThanOrEqualTo = x;
+    return this;
+  };
+
+  public equalTo = (x: Date): this => {
+    this.__config.equalTo = x;
+    return this;
+  };
+
+  validate = (
+    x: any,
+    key: string = "value"
+  ): {
+    value: Date;
+    valid: boolean;
+    errors: DateSchemaError[];
+  } => {
+    const { value, errors } = checkRunner(x, this.__config, key);
+
+    return {
+      valid: Boolean(errors.length === 0),
+      value,
+      errors,
+    };
+  };
+}
+
+export default DateSchema;

src/SchemaTypes/Date/types/DateError.ts

@@ -0,0 +1,11 @@
+import BaseError from "../../types/BaseError";
+
+enum DateSchemaErrorEnum {
+  None = "None",
+  Type = "Date/Type",
+  Value = "Date/InvalidValue",
+}
+
+type DateSchemaError = BaseError<DateSchemaErrorEnum>;
+
+export { DateSchemaError, DateSchemaErrorEnum };

src/SchemaTypes/Date/types/DateSchema.ts

@@ -0,0 +1,11 @@
+import BaseSchemaConfig from "../../types/BaseSchema";
+
+interface DateSchemaConfig extends BaseSchemaConfig<Date> {
+  greaterThan?: Date;
+  greaterThanOrEqualTo?: Date;
+  lessThan?: Date;
+  lessThanOrEqualTo?: Date;
+  equalTo?: Date;
+}
+
+export { DateSchemaConfig };

src/SchemaTypes/class.ts

@@ -1,3 +1,4 @@
+import { firestore } from "firebase-admin";
 import BaseError from "./types/BaseError";
 import BaseSchemaConfig from "./types/BaseSchema";
 import { KeyValueStore } from "./Object/types/KeyValue";
@@ -6,7 +7,7 @@ type ValidateFn<T> = (
   x: any,
   key: string
 ) => {
-  value: T | KeyValueStore;
+  value: T | KeyValueStore | firestore.Timestamp;
   valid: boolean;
   errors: BaseError[];
 };

src/SchemaTypes/index.ts

@@ -1,12 +1,14 @@
 import StringSchemaType from "./String/class";
 import NumberSchemaType from "./Number/class";
 import BooleanSchemaType from "./Boolean/class";
+import DateSchemaType from "./Date/class";
 import ObjectSchemaType from "./Object/class";
 import { KeyValueStore } from "./Object/types/KeyValue";
 
 const string = () => new StringSchemaType();
 const number = () => new NumberSchemaType();
 const boolean = () => new BooleanSchemaType();
+const date = () => new DateSchemaType();
 const object = <T extends KeyValueStore = any>() => new ObjectSchemaType<T>();
 
-export { string, number, boolean, object };
+export { string, number, boolean, date, object };

src/__tests__/SchemaTypes/Boolean/class.test.ts

@@ -37,7 +37,7 @@ describe("test Boolean Schema Parser", () => {
     const { valid, value, errors } = objectSchema.validate(testObj);
 
     expect(valid).toBe(false);
-    expect(value).toEqual({});
+    expect(value).toEqual(testObj);
     expect(errors).toEqual([
       {
         error: "isBoolean must be a boolean",