@solidxai/core 0.0.2

package/src/guards/authentication.guard.ts

@@ -0,0 +1,81 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { AUTH_TYPE_KEY } from '../decorators/auth.decorator';
+import { AuthType } from '../enums/auth-type.enum';
+import { AccessTokenGuard } from './access-token.guard';
+import { IS_PUBLIC_KEY } from '../decorators/public.decorator';
+import { PermissionMetadataService } from '../services/permission-metadata.service';
+import { ClsService } from 'nestjs-cls';
+
+@Injectable()
+export class AuthenticationGuard implements CanActivate {
+  private static readonly defaultAuthType = AuthType.Bearer;
+  private readonly authTypeGuardMap: Record<
+    AuthType,
+    CanActivate | CanActivate[]> = {
+      [AuthType.Bearer]: this.accessTokenGuard,
+      [AuthType.None]: { canActivate: () => true },
+    };
+
+  constructor(
+    private readonly reflector: Reflector,
+    private readonly accessTokenGuard: AccessTokenGuard,
+    private readonly permissionService: PermissionMetadataService,
+    private readonly cls: ClsService,
+  ) { }
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    // If method marked as public, then we return with true, else go ahead and apply the access token guard. 
+    const contextLog = context.getHandler();
+    const request = context.switchToHttp().getRequest();
+    request['isListedInPublicRole'] = false;
+
+    // Set IP and User-Agent into CLS context
+    const rawIp = request.headers['x-forwarded-for'] || request.socket?.remoteAddress || request.ip;
+    const ip = Array.isArray(rawIp) ? rawIp[0] :
+      typeof rawIp === 'string' ? rawIp.split(',')[0].trim() : '';
+    const userAgent = request.headers['user-agent'] || '';
+
+    this.cls.set('ipAddress', ip);
+    this.cls.set('userAgent', userAgent);
+
+    const isPublic = this.reflector.get(IS_PUBLIC_KEY, context.getHandler());
+    if (isPublic) {
+      return true;
+    }
+
+    // TODO: Check if this permission viz. contextPermission is listed in the Public role. 
+    const contextPermission = `${context.getClass().name}.${context.getHandler().name}`;
+
+    const permissionExistsInRole = await this.permissionService.permissionExistsInRole('Public', contextPermission)
+    if (permissionExistsInRole.length > 0) {
+      request['isListedInPublicRole'] = true;
+      return true
+    }
+
+    const authTypes = this.reflector.getAllAndOverride<AuthType[]>(
+      AUTH_TYPE_KEY,
+      [context.getHandler(), context.getClass()],
+    ) ?? [AuthenticationGuard.defaultAuthType];
+    const guards = authTypes.map((type) => this.authTypeGuardMap[type]).flat();
+    let error = new UnauthorizedException();
+
+    for (const instance of guards) {
+      const canActivate = await Promise.resolve(
+        instance.canActivate(context),
+      ).catch((err) => {
+        error = err;
+      });
+
+      if (canActivate) {
+        return true;
+      }
+    }
+    throw error;
+  }
+}

package/src/guards/permissions.guard.ts

@@ -0,0 +1,39 @@
+import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+import { ActiveUserData } from '../interfaces/active-user-data.interface';
+import { IS_PUBLIC_KEY } from '../decorators/public.decorator';
+import { REQUEST_USER_KEY } from "../constants";
+
+@Injectable()
+export class PermissionsGuard implements CanActivate {
+    constructor(
+        private readonly reflector: Reflector,
+    ) { }
+
+    canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
+        const isPublic = this.reflector.get(IS_PUBLIC_KEY, context.getHandler());
+        if (isPublic) {
+            return true;
+        }
+
+        // Permission is defined as ControllerName.methodName
+        const contextPermission = `${context.getClass().name}.${context.getHandler().name}`;
+
+        // Check if this permission viz. contextPermission is listed in the Public role. 
+        const request = context.switchToHttp().getRequest();
+        if (request.isListedInPublicRole === true) {
+            return true
+        }
+
+        // Else get hold of the active user & compare what roles they have and basis that return.
+        const user: ActiveUserData = context.switchToHttp().getRequest()[
+            REQUEST_USER_KEY
+        ];
+
+        const userPermissions = user ? user.permissions : [];
+
+        // If the userPermission set includes the context permission, it means they are allowed to access the specified method.
+        return userPermissions.includes(contextPermission);
+    }
+}

package/src/guards/roles.guard.ts

@@ -0,0 +1,37 @@
+/** NOT USED */
+import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+import { ROLES_KEY } from '../decorators/roles.decorator';
+import { ActiveUserData } from '../interfaces/active-user-data.interface';
+
+import { REQUEST_USER_KEY } from "../constants";
+
+@Injectable()
+export class RolesGuard implements CanActivate {
+  constructor(private readonly reflector: Reflector) { }
+
+  canActivate(
+    context: ExecutionContext,
+  ): boolean | Promise<boolean> | Observable<boolean> {
+    // Get hold of roles required, as configured at the handler or class level.
+    const contextRoles = this.reflector.getAllAndOverride<string[]>(ROLES_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+
+    // If nothing configured then we assume that all roles are allowed access, hence return true. 
+    if (!contextRoles) {
+      return true;
+    }
+
+    // Else get hold of the active user & compare what roles they have and basis that return.
+    const user: ActiveUserData = context.switchToHttp().getRequest()[
+      REQUEST_USER_KEY
+    ];
+
+    const usersRoles = user ? user.roles : [];
+
+    return contextRoles.some((role) => usersRoles.includes(role));
+  }
+}

package/src/helpers/command.service.ts

@@ -0,0 +1,74 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { spawn } from 'child_process';
+
+export type CommandWithArgs = {
+  command: string;
+  args: string[];
+};
+
+@Injectable()
+export class CommandService {
+  private readonly logger = new Logger(CommandService.name);
+
+  /**
+   * Escape an argument for Windows CMD shell
+   * Wraps in double quotes and escapes internal double quotes
+   */
+  private escapeArgForWindows(arg: string): string {
+    // If arg contains special characters, wrap in double quotes
+    // and escape internal double quotes with backslash
+    if (/[{}\s"^&|<>]/.test(arg)) {
+      // Escape internal double quotes with backslash for CMD
+      const escaped = arg.replace(/"/g, '\\"');
+      return `"${escaped}"`;
+    }
+    return arg;
+  }
+
+  /**
+   * Execute a command with arguments array (cross-platform compatible)
+   */
+  async executeCommandWithArgs(commandWithArgs: CommandWithArgs): Promise<string> {
+    const { command, args } = commandWithArgs;
+    this.logger.debug(`Executing command: ${command} ${args.join(' ')}`);
+
+    return new Promise<string>((resolve, reject) => {
+      const isWindows = process.platform === 'win32';
+
+      // On Windows with shell: true, we need to escape args containing special characters
+      const spawnArgs = isWindows
+        ? args.map(arg => this.escapeArgForWindows(arg))
+        : args;
+
+      const child = spawn(command, spawnArgs, {
+        shell: isWindows, // Use shell on Windows to handle .cmd files
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('error', (error) => {
+        this.logger.error(`Error executing command: ${command}`, error);
+        reject(error);
+      });
+
+      child.on('close', (code) => {
+        if (code !== 0) {
+          this.logger.error(`Command failed with code ${code}: ${command}`, stderr);
+          reject(new Error(stderr || `Command failed with exit code ${code}`));
+          return;
+        }
+        resolve(stdout);
+      });
+    });
+  }
+}

package/src/helpers/cors.helper.ts

@@ -0,0 +1,34 @@
+import { CorsOptions } from 'cors';
+
+/** Build CorsOptions from env; supports wildcards like https://*.example.com */
+export function buildDefaultCorsOptions(): CorsOptions {
+  const rawOrigins = process.env.SECURITY_CORS_ORIGINS ?? '*';
+
+  const allowed = rawOrigins.split(',').map(s => s.trim()).filter(Boolean);
+
+  const escapeRx = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const patternToRegex = (pattern: string): RegExp => {
+    const hasScheme = /^https?:\/\//i.test(pattern);
+    const schemePart = hasScheme ? '' : 'https?:\\/\\/';
+    if (pattern === '*' || pattern === '.*') return /^.*$/i;
+    const escaped = escapeRx(pattern)
+      .replace(/^https?:\/\//i, '')      // strip scheme if present
+      .replace(/\*/g, '[^.]+');          // * => one subdomain segment
+    return new RegExp(`^${schemePart}${escaped}(?::\\d+)?$`, 'i');
+  };
+
+  const matchers = allowed.map(patternToRegex);
+  const isAllowed = (origin: string) =>
+    matchers.length > 0 && matchers.some(rx => rx.test(origin));
+
+  return {
+    origin: (origin, cb) => {
+      if (!origin) return cb(null, true);           // allow no-origin (CLI/mobile/internal)
+      if (isAllowed(origin)) return cb(null, true);
+      return cb(new Error(`Origin ${origin} not allowed by CORS`), false);
+    },
+    methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+    allowedHeaders: ['Content-Type', 'Authorization'],
+    credentials: true,
+  };
+}

package/src/helpers/date.helper.ts

@@ -0,0 +1,63 @@
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+
+dayjs.extend(customParseFormat);
+
+export function parseFlexibleDate(value: any): Date | null {
+  if (!value) return null;
+
+  // Already a valid Date (ExcelJS often gives this)
+  if (value instanceof Date && !isNaN(value.getTime())) {
+    return value;
+  }
+
+  // Excel serial number
+  if (typeof value === 'number') {
+    const excelEpoch = new Date(Date.UTC(1899, 11, 30));
+    const d = new Date(excelEpoch.getTime() + value * 86400000);
+    return isNaN(d.getTime()) ? null : d;
+  }
+
+  let str = value.toString().trim();
+
+  // STRIP "(British Summer Time)" or any "(...)" suffix
+  str = str.replace(/\s*\(.*\)$/, '');
+
+  const formats = [
+    // strict business formats
+    'DD-MM-YYYY',
+
+    // common alternates
+    'YYYY-MM-DD',
+    'DD/MM/YYYY',
+    'MM/DD/YYYY',
+    'D-M-YYYY',
+    'YYYY/MM/DD',
+
+    // JS Date.toString() (without timezone name)
+    // (handle single-digit day + different offset shapes)
+    'ddd MMM D YYYY HH:mm:ss [GMT]ZZ', // GMT+0100
+    'ddd MMM DD YYYY HH:mm:ss [GMT]ZZ',
+    'ddd MMM D YYYY HH:mm:ss [GMT]Z',  // GMT+01:00
+    'ddd MMM DD YYYY HH:mm:ss [GMT]Z',
+
+    // ISO variants
+    'YYYY-MM-DD HH:mm:ss',
+    'YYYY-MM-DDTHH:mm:ss',
+    'YYYY-MM-DDTHH:mm:ss.SSS',
+    'YYYY-MM-DDTHH:mm:ssZ',
+  ];
+
+  const parsed = dayjs(str, formats, true); // strict
+  if (parsed.isValid()) {
+    return parsed.toDate();
+  }
+
+  // Fallback: native Date can parse this JS format very reliably
+  const native = new Date(str);
+  if (!isNaN(native.getTime())) {
+    return native;
+  }
+
+  return null;
+}

package/src/helpers/environment.helper.ts

@@ -0,0 +1,16 @@
+import { ConfigService } from "@nestjs/config";
+import { isNumber } from 'class-validator';
+
+export function parseBooleanEnv(key: string, defaultValue: boolean = false): boolean {
+    const value = process.env[key];
+    if (value === undefined) {
+        return defaultValue;
+    }
+    return value.toLowerCase() === 'true';
+}
+
+export function isRedisConfigured(configService: ConfigService): boolean {
+    const host = configService.get<string>('REDIS_HOST');
+    const port = configService.get<string>('REDIS_PORT');
+    return host && port && isNumber(parseInt(port));
+}

package/src/helpers/error-mapper.service.ts

@@ -0,0 +1,120 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { ErrorCode, ErrorMeta, ErrorRule, IErrorCodeProvider } from 'src/interfaces';
+@Injectable()
+export class ErrorMapperService {
+    private readonly logger = new Logger(ErrorMapperService.name);
+
+    constructor(private readonly solidRegistry: SolidRegistry) { }
+
+    /** Map an exception object (or string) to a canonical ErrorCode */
+    mapException(exc: unknown): ErrorCode {
+        const combined = this.combineErrorText(exc);
+        return this.matchCode(combined);
+    }
+
+    /** Map plain message/trace to ErrorCode */
+    mapMessage(message: string, trace?: string): ErrorCode {
+        const combined = `${message ?? ''}\n${trace ?? ''}`.toLowerCase();
+        return this.matchCode(combined);
+    }
+
+    /** Get static message for a given code */
+    getMessage(code: ErrorCode): string {
+        const meta = this.lookupMeta(code);
+        return (meta ?? { message: 'An unexpected error occurred.' }).message;
+    }
+
+    /** Get default HTTP status for a code (falls back to 500) */
+    getHttpStatus(code: ErrorCode): number {
+        const meta = this.lookupMeta(code);
+        return meta?.httpStatus ?? 500;
+    }
+
+    // ---- internal helpers ----
+    private matchCode(combined: string): ErrorCode {
+        const rules = this.getAllRulesSorted();
+        for (const rule of rules) {
+            try {
+                if (rule.match(combined)) return rule.code;
+            } catch (e) {
+                // Defensive: bad provider shouldn't crash mapping
+                this.logger.warn(`Error rule threw in match(): code=${rule.code} provider? — ${e}`);
+            }
+        }
+        return 'solidx-unknown-error';
+    }
+
+    private lookupMeta(code: ErrorCode): ErrorMeta | undefined {
+        // Prefer the first rule with that code
+        const rules = this.getAllRulesSorted();
+        const rule = rules.find((r) => r.code === code);
+        if (rule?.meta) return rule.meta;
+
+        // Optional: ask providers directly if they implement resolve()
+        const providers = this.getProviders();
+        for (const p of providers) {
+            if (p.resolve) {
+                const meta = p.resolve(code);
+                if (meta) return meta;
+            }
+        }
+        return undefined;
+    }
+
+    private getAllRulesSorted(): ReadonlyArray<ErrorRule> {
+        const providers = this.getProviders();
+        const all: ErrorRule[] = [];
+        for (const p of providers) {
+            try {
+                const rules = p.rules() ?? [];
+                all.push(...rules);
+            } catch (e) {
+                this.logger.warn(`ErrorCodeProvider.rules() failed for ${p.name?.()}: ${e}`);
+            }
+        }
+        // Sort by priority desc; default 0
+        return all.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    }
+
+    private getProviders(): IErrorCodeProvider[] {
+        // convert InstanceWrapper → instance
+        return this.solidRegistry
+            .getErrorCodeProviders()
+            .map((w) => w.instance)
+            .filter(Boolean) as IErrorCodeProvider[];
+    }
+
+    private combineErrorText(exc: unknown): string {
+        if (typeof exc === 'string') return exc.toLowerCase();
+
+        if (exc instanceof Error) {
+            const message = exc.message ?? '';
+            const stack = exc.stack ?? '';
+            return `${message}\n${stack}`.toLowerCase();
+        }
+
+        if (exc && typeof exc === 'object') {
+            try {
+                const obj = exc as Record<string, unknown>;
+                const msg = String(obj.message ?? (obj as any)['Message'] ?? '');
+                const name = String(obj.name ?? (obj as any)['__type'] ?? '');
+                const stack = String((obj as any).stack ?? '');
+                const json = this.safeJsonStringify(obj);
+                return `${name}\n${msg}\n${stack}\n${json}`.toLowerCase();
+            } catch {
+                // ignore
+            }
+        }
+
+        return String(exc ?? '').toLowerCase();
+    }
+
+    private safeJsonStringify(obj: unknown): string {
+        try {
+            return JSON.stringify(obj);
+        } catch {
+            return '';
+        }
+    }
+}

package/src/helpers/field-crud-managers/BigIntFieldCrudManager.ts

@@ -0,0 +1,68 @@
+import { isEmpty, isNotEmpty, max, min } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface BigIntFieldOptions {
+    min: number | undefined | null; // FIXME Do we want to support min and max for bigint? or number should suffice?
+    max: number | undefined | null; // FIXME Do we want to support min and max for bigint? or number should suffice?
+    required: boolean | undefined | null;
+    fieldName: string;
+}
+
+export class BigIntFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: BigIntFieldOptions) {
+    }
+
+    validate(createDto: any): ValidationError[] {
+        let fieldValue: any = createDto[this.options.fieldName];
+        if (fieldValue !== undefined && fieldValue !== null) {
+            try {
+                if (typeof fieldValue === 'string' || typeof fieldValue === 'number') {
+                    fieldValue = BigInt(fieldValue);
+                }
+            } catch (err) {
+                return [{ field: this.options.fieldName, error: 'Invalid numeric value' }];
+            }
+        }
+        return this.applyValidations(fieldValue);
+    }
+
+    private applyValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }) : "no errors";
+        if (isNotEmpty(fieldValue)) {
+            errors.push(...this.applyFormatValidations(fieldValue));
+        }
+        return errors;
+    }
+
+    private applyFormatValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        !this.isBigInt(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not a bigint' }) : "no errors";
+        this.isApplyMinValidation() && !min(fieldValue, this.options.min) ? errors.push({ field: this.options.fieldName, error: 'Field value is lesser than minimum required' }) : "no errors"; //FIXME min length to be handled
+        this.isApplyMaxValidation() && !max(fieldValue, this.options.max) ? errors.push({ field: this.options.fieldName, error: 'Field value is greater than maximum required' }) : "no errors";
+        return errors;
+    }
+
+    transformForCreate(createDto: any): any {
+        return createDto;
+    }
+
+    // Validation to be applied
+    private isApplyMinValidation(): boolean {
+        return this.options.min > 0;
+    }
+
+    private isApplyMaxValidation(): boolean {
+        return this.options.max > 0;
+    }
+
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+
+    private isBigInt(value: any): boolean {
+        const valueType = typeof value;
+        return valueType === 'bigint' || (valueType === 'number' && Number.isFinite(value));
+    }
+}

package/src/helpers/field-crud-managers/BooleanFieldCrudManager.ts

@@ -0,0 +1,44 @@
+import { isBoolean, isEmpty, isNotEmpty } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface BooleanFieldOptions {
+    required: boolean | undefined | null;
+    fieldName: string;
+}
+
+export class BooleanFieldCrudManager implements FieldCrudManager {
+    private options: BooleanFieldOptions;
+
+    constructor(options: BooleanFieldOptions) {
+        this.options = options
+    }
+
+    validate(dto: any): ValidationError[] {
+        const fieldValue: any = dto[this.options.fieldName];
+        return this.applyValidations(fieldValue);
+    }
+
+    private applyValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }): "no errors";
+        if (isNotEmpty(fieldValue)) {
+            errors.push(...this.applyFormatValidations(fieldValue));
+        }
+        return errors;
+    }
+
+    private applyFormatValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        !isBoolean(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is not a boolean value` }): "no errors";
+        return errors;
+    }
+
+    transformForCreate(dto: any): any {
+        return dto;
+    }
+
+    // Validation to be applied
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+}

package/src/helpers/field-crud-managers/ComputedFieldCrudManager.ts

@@ -0,0 +1,47 @@
+import { DiscoveryService } from "@nestjs/core";
+import { ComputedFieldValueType } from "src/dtos/create-field-metadata.dto";
+import { FieldCrudManager, IComputedFieldProvider, ValidationError } from "src/interfaces";
+
+export interface ComputedFieldOptions {
+    computedFieldProvider: string;
+    computedFieldValueType: ComputedFieldValueType;
+    computedFieldValueProviderCtxt: any;
+    fieldName: string;
+    discoveryService: DiscoveryService;
+    skipComputation: boolean;
+}
+
+export class ComputedFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: ComputedFieldOptions) {
+    }
+
+    async validate(): Promise<ValidationError[]> {
+        return []; //Since this is a computed field, we can skip the validation, by returning an empty array
+    }
+
+    async transformForCreate(dto: any): Promise<any> {
+        if (this.options.skipComputation) {
+            return dto; // Skip computation if the flag is set
+        }
+        const ctxt = this.options.computedFieldValueProviderCtxt ? JSON.parse(this.options.computedFieldValueProviderCtxt) : {};
+        dto[this.options.fieldName] = await this.computeValue(dto, ctxt);
+        return dto;
+    }
+
+    private async computeValue(dto: any, ctxt: any): Promise<string|number> {
+        const provider = this.providerInstance<any, any>(this.options.computedFieldProvider);
+        return provider.computeValue(dto, ctxt);
+    }
+
+    private providerInstance<DTO, T>(computedFieldProvider: string): IComputedFieldProvider<T> {
+        const provider = this.options.discoveryService
+            .getProviders()
+            .filter((provider) => provider.name === computedFieldProvider) //TODO : Add an extra check to verify if the provider is of type IComputedFieldProvider
+            .pop();
+        if (!provider) {
+            throw new Error(`Provider for ${computedFieldProvider} not found`);
+        }
+        return provider.instance as IComputedFieldProvider<T>;
+    }
+}

package/src/helpers/field-crud-managers/DateFieldCrudManager.ts

@@ -0,0 +1,42 @@
+import { isDate, isEmpty, isNotEmpty } from "class-validator";
+import { FieldCrudManager, ValidationError } from "src/interfaces";
+
+export interface DateFieldOptions {
+    required: boolean | undefined | null;
+    fieldName: string;
+}
+
+export class DateFieldCrudManager implements FieldCrudManager {
+
+    constructor(private readonly options: DateFieldOptions) {
+    }
+
+    validate(dto: any): ValidationError[] {
+        const fieldValue: any = dto[this.options.fieldName];
+        return this.applyValidations(fieldValue);
+    }
+
+    private applyValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        this.isApplyRequiredValidation() && isEmpty(fieldValue) ? errors.push({ field: this.options.fieldName, error: `Field: ${this.options.fieldName} is required` }): "no errors";
+        if (isNotEmpty(fieldValue)) {
+            errors.push(...this.applyFormatValidations(fieldValue));
+        }
+        return errors;
+    }
+
+    private applyFormatValidations(fieldValue: any): ValidationError[] {
+        const errors: ValidationError[] = [];
+        !isDate(fieldValue) ? errors.push({ field: this.options.fieldName, error: 'Field is not a date' }) : "no errors";
+        return errors;
+    }
+
+    transformForCreate(dto: any): any {
+        return dto;
+    }
+
+    // Validation to be applied
+    private isApplyRequiredValidation(): boolean {
+        return this.options.required;
+    }
+}