drimion 0.1.0

package/dist/kernel/libs/utils.ts

@@ -0,0 +1,260 @@
+import type { CalcOpt } from "../types/utils.types";
+import { DecrementTime, IncrementTime } from "../utils/date.utils";
+import { Divide, Multiply, Subtract, Sum } from "../utils/number.utils";
+import { RemoveChars, RemoveSpaces, ReplaceChars } from "../utils/string.utils";
+import validator, { type Validator } from "./validator";
+
+/**
+ * @description
+ * Utility class providing various helper methods for date, number, and string manipulations.
+ */
+export class Utils {
+	private static instance: Utils;
+	private static validator: Validator = validator;
+
+	private constructor() {
+		Utils.validator = validator;
+	}
+
+	/**
+	 * @description
+	 * Creates a singleton instance of the Utils class.
+	 *
+	 * @returns {Utils} An instance of the Utils class.
+	 */
+	public static create(): Utils {
+		if (!Utils.instance) Utils.instance = new Utils();
+		return Utils.instance;
+	}
+
+	/**
+	 * @description
+	 * Provides date manipulation utilities for adding or removing units of time.
+	 *
+	 * @param target The date to manipulate.
+	 * @returns An object with methods for adding or removing units of time (days, hours, etc.).
+	 */
+	public date(target: Date) {
+		return {
+			add: (value: number) => ({
+				/**
+				 * @description
+				 * add days to a date.
+				 *
+				 * @returns a new date with incremented days.
+				 */
+				days: () => new Date(IncrementTime(target, value, "day")),
+				/**
+				 * @description
+				 * add hours to a date.
+				 *
+				 * @returns a new date with incremented hours.
+				 */
+				hours: () => new Date(IncrementTime(target, value, "hour")),
+				/**
+				 * @description
+				 * add minutes to a date.
+				 *
+				 * @returns a new date with incremented minutes.
+				 */
+				minutes: () => new Date(IncrementTime(target, value, "minute")),
+				/**
+				 * @description
+				 * add weeks to a date.
+				 *
+				 * @returns a new date with incremented weeks.
+				 */
+				weeks: () => new Date(IncrementTime(target, value, "week")),
+				/**
+				 * @description
+				 * add months to a date.
+				 *
+				 * @returns a new date with incremented months.
+				 */
+				months: () => new Date(IncrementTime(target, value, "month")),
+				/**
+				 * @description
+				 * add years to a date.
+				 *
+				 * @returns a new date with incremented years.
+				 */
+				years: () => new Date(IncrementTime(target, value, "year")),
+			}),
+			subtract: (value: number) => ({
+				/**
+				 * @description
+				 * remove days from a date.
+				 *
+				 * @returns a new date with removed days.
+				 */
+				days: () => new Date(DecrementTime(target, value, "day")),
+				/**
+				 * @description
+				 * remove hours from a date.
+				 *
+				 * @returns a new date with removed hours.
+				 */
+				hours: () => new Date(DecrementTime(target, value, "hour")),
+				/**
+				 * @description
+				 * remove minutes from a date.
+				 *
+				 * @returns a new date with removed minutes.
+				 */
+				minutes: () => new Date(DecrementTime(target, value, "minute")),
+				/**
+				 * @description
+				 * remove weeks from a date.
+				 *
+				 * @returns a new date with removed weeks.
+				 */
+				weeks: () => new Date(DecrementTime(target, value, "week")),
+				/**
+				 * @description
+				 * remove months from a date.
+				 *
+				 * @returns a new date with removed months.
+				 */
+				months: () => new Date(DecrementTime(target, value, "month")),
+				/**
+				 * @description
+				 * remove years from a date.
+				 *
+				 * @returns a new date with removed years.
+				 */
+				years: () => new Date(DecrementTime(target, value, "year")),
+			}),
+		};
+	}
+
+	/**
+	 * @description
+	 * Provides number manipulation utilities, including mathematical operations.
+	 *
+	 * @param target The number to manipulate.
+	 * @returns An object with methods for multiplication, division, subtraction, and addition.
+	 */
+	number(target: number) {
+		return {
+			/**
+			 * @description
+			 * multiply a value for another one.
+			 *
+			 * @param value number or string (number)
+			 * @param options as object with fractionDigits option
+			 * @default fractionDigits 5
+			 * @returns result as number
+			 * @sumary If you provide a string NAN (not a number) 0 will be considered as value.
+			 */
+			multiplyBy: (value: number, opt?: CalcOpt): number =>
+				Multiply(target, value, opt?.fractionDigits),
+			/**
+			 * @description
+			 * divide a value for another one.
+			 *
+			 * @param value number or string
+			 * @param options as object with fractionDigits option
+			 * @default fractionDigits 5
+			 * @returns result as number
+			 * @sumary If you provide a string NAN (not a number) 0 will be considered as value.
+			 */
+			divideBy: (value: number, opt?: CalcOpt): number =>
+				Divide(target, value, opt?.fractionDigits),
+			/**
+			 * @description
+			 * subtract a value for another one.
+			 *
+			 * @param value number or string
+			 * @param options as object with fractionDigits option
+			 * @default fractionDigits 5
+			 * @returns result as number
+			 * @sumary If you provide a string NAN (not a number) 0 will be considered as value.
+			 */
+			subtract: (value: number, opt?: CalcOpt): number =>
+				Subtract(target, value, opt?.fractionDigits),
+			/**
+			 * @description
+			 * sum a value with another one.
+			 *
+			 * @param value number or string
+			 * @param options as object with fractionDigits option
+			 * @default fractionDigits 5
+			 * @returns result as number
+			 * @sumary If you provide a string NAN (not a number) 0 will be considered as value.
+			 */
+			sum: (value: number, opt?: CalcOpt): number =>
+				Sum(target, value, opt?.fractionDigits),
+		};
+	}
+
+	/**
+	 * @description
+	 * Provides string manipulation utilities, including removing or replacing characters.
+	 *
+	 * @param target The string to manipulate.
+	 * @returns An object with methods for character removal, space removal, and replacement.
+	 */
+	string(target: string) {
+		return {
+			/**
+			 * @description
+			 * remove all special chars from a string.
+			 *
+			 * @returns string with no special chars.
+			 * @summary special chars: based on ascii table
+			 * @example
+			 * (asciiCode >= 33 && asciiCode <= 47) ||
+			 * (asciiCode >= 58 && asciiCode <= 64) ||
+			 * (asciiCode >= 91 && asciiCode <= 96) ||
+			 * (asciiCode >= 123 && asciiCode <= 126)
+			 */
+			removeSpecialChars: () =>
+				RemoveChars(target, (char: string) =>
+					Utils.validator.string(char).isSpecialChar(),
+				),
+			/**
+			 * @description
+			 * remove all spaces from text.
+			 *
+			 * @returns string with no spaces
+			 */
+			removeSpaces: (): string => RemoveSpaces(target),
+			/**
+			 * @description
+			 * remove all numbers from a text
+			 *
+			 * @returns string with no numbers.
+			 */
+			removeNumbers: (): string =>
+				RemoveChars(target, (char: string) =>
+					Utils.validator.string(char).hasOnlyNumbers(),
+				),
+			/**
+			 * @description
+			 * remove only specific character from a text.
+			 *
+			 * @param char character to be removed.
+			 * @returns string without char.
+			 * @memberof replace. If you need to remove a word or more than one character from a text use replace function.
+			 * @see replace
+			 */
+			removeChar: (char: string) =>
+				RemoveChars(target, (val: string) => val === char),
+			/**
+			 * @description
+			 * replace any character or word from an string for some provided value.
+			 *
+			 * @param char character or word to be replaced.
+			 * @param value character or word to be aplied.
+			 * @returns text with replaced value.
+			 * @example
+			 * string("hello world").replace("world").to("dear");
+			 */
+			replace: (char: string) => ({
+				to: (value: string | number) => ReplaceChars(target, char, value),
+			}),
+		};
+	}
+}
+
+export default Utils.create();

package/dist/kernel/libs/validator.ts

@@ -0,0 +1,353 @@
+import type { Aggregate, Entity, ID, ValueObject } from "../core";
+import type { AnyObject } from "../types/utils.types";
+import { Stringify } from "../utils/string.utils";
+
+/**
+ * @description
+ * A utility class for validating various data types, including numbers, strings, objects, dates, and more.
+ * Provides methods to check the type and properties of values, as well as to perform specific validations.
+ */
+export class Validator {
+	private static instance: Validator = null as unknown as Validator;
+
+	private constructor() {}
+
+	/**
+	 * @description
+	 * Creates or retrieves the singleton instance of the `Validator` class.
+	 *
+	 * @returns {Validator} The instance of the `Validator` class.
+	 */
+	public static create(): Validator {
+		if (!Validator.instance) Validator.instance = new Validator();
+		return Validator.instance;
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is an aggregate.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is an aggregate, false otherwise.
+	 */
+	public isAggregate(props: unknown): props is Aggregate<never> {
+		if (props === null || typeof props !== "object") return false;
+		return (props as AnyObject).__aggregate === true;
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is an array.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is an array, false otherwise.
+	 */
+	public isArray(props: unknown): props is unknown[] {
+		return Array.isArray(props);
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is a boolean.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is a boolean, false otherwise.
+	 */
+	public isBoolean(props: unknown): props is boolean {
+		return typeof props === "boolean";
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is a date.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is a date, false otherwise.
+	 */
+	public isDate(props: unknown): props is Date {
+		return props instanceof Date;
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is an entity (but not an aggregate).
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is an entity, false otherwise.
+	 */
+	public isEntity(props: unknown): props is Entity<never> {
+		if (props === null || typeof props !== "object") return false;
+		return (props as AnyObject).__kind === "Entity";
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is a function.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is a function, false otherwise.
+	 */
+	public isFunction(props: unknown): props is (...args: unknown[]) => unknown {
+		return typeof props === "function";
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is an ID instance.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is an ID, false otherwise.
+	 */
+	public isID(props: unknown): props is ID {
+		if (props === null || typeof props !== "object") return false;
+		return (props as AnyObject).__kind === "ID";
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is null.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is null, false otherwise.
+	 */
+	public isNull(props: unknown): props is null {
+		return props === null;
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is a number.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is a number, false otherwise.
+	 */
+	public isNumber(props: unknown): props is number {
+		return typeof props === "number";
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is an object, excluding arrays, entities, aggregates, and value objects.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is an object, false otherwise.
+	 */
+	public isObject(props: unknown): props is Record<string, unknown> {
+		const isObj = typeof props === "object";
+		if (!isObj || props === null) return false;
+		if (Stringify(props) === Stringify({})) return true;
+		const hasKeys = Object.keys(props).length > 0;
+		const isNotArray = !Validator.instance.isArray(props);
+		const isNotEntity = !Validator.instance.isEntity(props);
+		const isNotAggregate = !Validator.instance.isAggregate(props);
+		const isNotValueObject = !Validator.instance.isValueObject(props);
+		const isNotId = !Validator.instance.isID(props);
+		return (
+			hasKeys &&
+			isNotAggregate &&
+			isNotArray &&
+			isNotEntity &&
+			isNotValueObject &&
+			isNotId
+		);
+	}
+
+	/**
+	 * @description
+	 * Checks if a character at a specified index is a special character based on ASCII codes.
+	 *
+	 * @param char The character to check.
+	 * @param index The index of the character.
+	 * @returns {boolean} True if the character is a special character, false otherwise.
+	 */
+	private static isSpecialChar(char: string, index: number): boolean {
+		const asciiCode = char.charCodeAt(index);
+		return (
+			(asciiCode >= 33 && asciiCode <= 47) ||
+			(asciiCode >= 58 && asciiCode <= 64) ||
+			(asciiCode >= 91 && asciiCode <= 96) ||
+			(asciiCode >= 123 && asciiCode <= 126)
+		);
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is a symbol.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is a symbol, false otherwise.
+	 */
+	public isSymbol(props: unknown): props is symbol {
+		return typeof props === "symbol";
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is a string.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is a string, false otherwise.
+	 */
+	public isString(props: unknown): props is string {
+		return typeof props === "string";
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is undefined.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is undefined, false otherwise.
+	 */
+	public isUndefined(props: unknown): props is undefined {
+		return typeof props === "undefined";
+	}
+
+	/**
+	 * @description
+	 * Checks if the provided value is a value object.
+	 *
+	 * @param props The value to check.
+	 * @returns {boolean} True if the value is a value object, false otherwise.
+	 */
+	public isValueObject(props: unknown): props is ValueObject<never> {
+		if (props === null || typeof props !== "object") return false;
+		return (props as AnyObject).__kind === "ValueObject";
+	}
+
+	public date(target: Date) {
+		return {
+			isBeforeThan: (value: Date): boolean =>
+				Validator.instance.isDate(target) &&
+				Validator.instance.isDate(value) &&
+				target.getTime() < value.getTime(),
+			isBeforeOrEqualTo: (value: Date): boolean =>
+				Validator.instance.isDate(target) &&
+				Validator.instance.isDate(value) &&
+				target.getTime() <= value.getTime(),
+			isAfterNow: (): boolean =>
+				Validator.instance.isDate(target) && target.getTime() > Date.now(),
+			isBeforeNow: (): boolean =>
+				Validator.instance.isDate(target) && target.getTime() < Date.now(),
+			isBetween: (start: Date, end: Date): boolean =>
+				Validator.instance.isDate(target) &&
+				target.getTime() > start.getTime() &&
+				target.getTime() < end.getTime(),
+			isWeekend: (): boolean =>
+				(Validator.instance.isDate(target) && target.getDay() === 0) ||
+				(Validator.instance.isDate(target) && target.getDay() === 6),
+			isAfterThan: (value: Date): boolean =>
+				Validator.instance.isDate(target) &&
+				Validator.instance.isDate(value) &&
+				target.getTime() > value.getTime(),
+			isAfterOrEqualTo: (value: Date): boolean =>
+				Validator.instance.isDate(target) &&
+				Validator.instance.isDate(value) &&
+				target.getTime() >= value.getTime(),
+		};
+	}
+
+	public number(target: number) {
+		return {
+			isEqualTo: (value: number): boolean =>
+				Validator.instance.isNumber(target) &&
+				Validator.instance.isNumber(value) &&
+				target === value,
+			isGreaterThan: (value: number): boolean =>
+				Validator.instance.isNumber(target) &&
+				Validator.instance.isNumber(value) &&
+				target > value,
+			isLessThan: (value: number): boolean =>
+				Validator.instance.isNumber(target) &&
+				Validator.instance.isNumber(value) &&
+				target < value,
+			isLessOrEqualTo: (value: number): boolean =>
+				Validator.instance.isNumber(target) &&
+				Validator.instance.isNumber(value) &&
+				target <= value,
+			isGreaterOrEqualTo: (value: number): boolean =>
+				Validator.instance.isNumber(target) &&
+				Validator.instance.isNumber(value) &&
+				target >= value,
+			isSafeInteger: (): boolean =>
+				Validator.instance.isNumber(target) &&
+				target <= Number.MAX_SAFE_INTEGER &&
+				target >= Number.MIN_SAFE_INTEGER,
+			isPositive: (): boolean =>
+				Validator.instance.isNumber(target) && target >= 0,
+			isNegative: (): boolean =>
+				Validator.instance.isNumber(target) && target < 0,
+			isEven: (): boolean =>
+				Validator.instance.isNumber(target) && target % 2 === 0,
+			isInteger: (): boolean =>
+				Validator.instance.isNumber(target) &&
+				target - Math.trunc(target) === 0,
+			isBetween: (min: number, max: number): boolean =>
+				Validator.instance.isNumber(target) && target < max && target > min,
+			isBetweenOrEqual: (min: number, max: number): boolean =>
+				Validator.instance.isNumber(target) && target <= max && target >= min,
+		};
+	}
+
+	public string(target: string) {
+		return {
+			isSpecialChar: (index = 0): boolean =>
+				Validator.instance.isString(target[index]) &&
+				Validator.isSpecialChar(target, index),
+			hasSpecialChar: (): boolean =>
+				Validator.instance.isString(target) &&
+				target
+					.split("")
+					.map((char) => Validator.isSpecialChar(char, 0))
+					.includes(true),
+			hasLengthGreaterThan: (length: number): boolean =>
+				Validator.instance.isString(target) && target.length > length,
+			hasLengthGreaterOrEqualTo: (length: number): boolean =>
+				Validator.instance.isString(target) && target.length >= length,
+			hasLengthLessThan: (length: number): boolean =>
+				Validator.instance.isString(target) && target.length < length,
+			hasLengthLessOrEqualTo: (length: number): boolean =>
+				Validator.instance.isString(target) && target.length <= length,
+			hasLengthEqualTo: (length: number): boolean =>
+				Validator.instance.isString(target) && target.length === length,
+			hasLengthBetween: (min: number, max: number): boolean =>
+				Validator.instance.isString(target) &&
+				target.length > min &&
+				target.length < max,
+			hasLengthBetweenOrEqual: (min: number, max: number): boolean =>
+				Validator.instance.isString(target) &&
+				target.length >= min &&
+				target.length <= max,
+			includes: (value: string): boolean =>
+				(Validator.instance.isString(target) && target.includes(value)) ||
+				value
+					.split("")
+					.map((char) => target.includes(char))
+					.includes(true),
+			isEmpty: (): boolean =>
+				Validator.instance.isUndefined(target) ||
+				Validator.instance.isNull(target) ||
+				(Validator.instance.isString(target) && target.trim() === ""),
+			match: (regex: RegExp): boolean => regex.test(target),
+			hasOnlyNumbers: (): boolean =>
+				Validator.instance.isString(target) &&
+				target
+					.split("")
+					.map((n) => n.charCodeAt(0) >= 48 && n.charCodeAt(0) <= 57)
+					.every((v) => v === true),
+			hasOnlyLetters: (): boolean =>
+				Validator.instance.isString(target) &&
+				target
+					.toUpperCase()
+					.split("")
+					.map((n) => n.charCodeAt(0) >= 65 && n.charCodeAt(0) <= 90)
+					.every((v) => v === true),
+			isEqual: (value: string) =>
+				Validator.instance.isString(target) &&
+				Validator.instance.isString(value) &&
+				target === value,
+		};
+	}
+}
+
+export default Validator.create();

package/dist/kernel/types/adapter.types.ts

@@ -0,0 +1,26 @@
+import type { IResult } from "./result.types";
+
+/**
+ * @description
+ * Represents a simpler adapter for transforming objects.
+ *
+ * @template A The input type.
+ * @template B The output type.
+ */
+export interface Adapter<A = unknown, B = unknown> {
+	adaptOne(item: A): B;
+	adaptMany?(items: Array<A>): Array<B>;
+}
+
+/**
+ * @description
+ * Represents an adapter that transforms one type to another.
+ *
+ * @template F The input type.
+ * @template T The output type.
+ * @template E The error type (default: void).
+ * @template M The metadata type (default: void).
+ */
+export interface IAdapter<F, T, E = void, M = void> {
+	build(target: F): IResult<T, E, M>;
+}

package/dist/kernel/types/command.types.ts

@@ -0,0 +1,37 @@
+import type { IResult } from "./result.types";
+
+/**
+ * @description
+ * Represents a command — an operation that changes state and returns a Result.
+ *
+ * @template Input The input type.
+ * @template Output The output type.
+ */
+export interface ICommand<Input = void, Output = void> {
+	execute(input: Input): Promise<IResult<Output, string>>;
+}
+
+/**
+ * @description
+ * Represents a query — a read-only operation that returns data without changing state.
+ * Queries should never produce side effects.
+ *
+ * @template Input The query parameters type.
+ * @template Output The returned data type.
+ */
+export interface IQuery<Input = void, Output = void> {
+	execute(input: Input): Promise<IResult<Output, string>>;
+}
+
+/**
+ * @description
+ * Convenience alias — a use case is either a Command or a Query.
+ * Use `ICommand` when the operation mutates state.
+ * Use `IQuery` when the operation is read-only.
+ *
+ * @template Input The input type.
+ * @template Output The output type.
+ */
+export type IUseCase<Input = void, Output = void> =
+	| ICommand<Input, Output>
+	| IQuery<Input, Output>;