@haskou/value-objects 1.1.1 → 1.1.3

package/jest.config.ts

@@ -1,30 +0,0 @@
-import type { Config } from '@jest/types';
-
-// Sync object
-const config: Config.InitialOptions = {
-  collectCoverageFrom: ['<rootDir>/src/**/*.ts'],
-  coverageDirectory: '<rootDir>/tests/coverage',
-  coveragePathIgnorePatterns: ['<rootDir>/node_modules/', 'index.ts'],
-  coverageReporters: ['html', 'lcov', 'text'],
-  globals: {
-    'ts-jest': {
-      tsconfig: 'tsconfig.jest.json',
-    },
-  },
-  moduleDirectories: ['node_modules', 'src'],
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
-  moduleNameMapper: {
-    '^@app/(.*)$': '<rootDir>/src/$1',
-  },
-  preset: 'ts-jest',
-  roots: ['<rootDir>/src/', '<rootDir>/tests/'],
-  setupFilesAfterEnv: ['<rootDir>/tests/setup.jest.ts'],
-  testEnvironment: 'node',
-  testPathIgnorePatterns: ['<rootDir>/node_modules/', 'index.ts'],
-  transform: {
-    '^.+\\.ts': 'ts-jest',
-  },
-  verbose: true,
-};
-
-export default config;

package/src/errors/BaseError.ts

@@ -1,20 +0,0 @@
-export class BaseError extends Error {
-  private readonly isBaseError = true;
-  public static isBaseError(error: unknown): boolean {
-    return !!(error as BaseError).isBaseError;
-  }
-
-  constructor(message: string, prototype: object = BaseError.prototype) {
-    super(message);
-    this.name = this.constructor.name;
-    Object.setPrototypeOf(this, prototype);
-  }
-
-  public toString(): string {
-    return `[${this.name}]: ${this.message}`;
-  }
-
-  public getStack(): string {
-    return this.stack || '';
-  }
-}

package/src/errors/DomainError.ts

@@ -1,12 +0,0 @@
-import { BaseError } from './BaseError';
-
-export class DomainError extends BaseError {
-  protected readonly isDomainError = true;
-  public static isDomainError(error: unknown): boolean {
-    return !!(error as DomainError).isDomainError;
-  }
-
-  constructor(message: string) {
-    super(message, new.target.prototype);
-  }
-}

package/src/errors/InvalidColorError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidColorError extends DomainError {
-  constructor(value: string) {
-    super(`Invalid color value: ${value}. Must be a valid hex color code.`);
-  }
-}

package/src/errors/InvalidDayError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidDayError extends DomainError {
-  constructor(invalidDay: unknown) {
-    super(`Invalid day ${String(invalidDay)}`);
-  }
-}

package/src/errors/InvalidDayFormatError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidDayFormatError extends DomainError {
-  constructor(invalidDate: string) {
-    super(`Invalid day ${invalidDate}. Expected YYYY-MM-DD. `);
-  }
-}

package/src/errors/InvalidEmailError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidEmailError extends DomainError {
-  constructor(value: string) {
-    super(`Invalid email format: ${value}`);
-  }
-}

package/src/errors/InvalidFormatError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from '../errors/DomainError';
-
-export class InvalidFormatError extends DomainError {
-  constructor(value?: string) {
-    super(`Invalid Format Error with value: '${value}'`);
-  }
-}

package/src/errors/InvalidHashError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidHashError extends DomainError {
-  constructor(type: string, value: string) {
-    super(`Invalid ${type} hash: ${value}`);
-  }
-}

package/src/errors/InvalidHourError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidHourError extends DomainError {
-  constructor() {
-    super(`Invalid hour`);
-  }
-}

package/src/errors/InvalidIntegerError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidIntegerError extends DomainError {
-  constructor(value: number) {
-    super(`Invalid integer value ${value}`);
-  }
-}

package/src/errors/InvalidLatitudeError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidLatitudeError extends DomainError {
-  constructor(value: number) {
-    super(`Invalid latitude: ${value}. Must be between -90 and 90`);
-  }
-}

package/src/errors/InvalidLengthError.ts

@@ -1,9 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidLengthError extends DomainError {
-  constructor(value: unknown, length: number) {
-    super(
-      `Invalid Length Error with value: '${value}' expected length: '${length}'`,
-    );
-  }
-}

package/src/errors/InvalidLongitudeError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidLongitudeError extends DomainError {
-  constructor(value: number) {
-    super(`Invalid longitude: ${value}. Must be between -180 and 180`);
-  }
-}

package/src/errors/InvalidMinutesError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidMinutesError extends DomainError {
-  constructor() {
-    super(`Invalid minutes`);
-  }
-}

package/src/errors/InvalidNumberError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidNumberError extends DomainError {
-  constructor(invalidNumber: unknown) {
-    super(`Invalid number ${String(invalidNumber)}`);
-  }
-}

package/src/errors/InvalidPositiveNumberError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidPositiveNumberError extends DomainError {
-  constructor() {
-    super(`Value must be greater or equal than 0`);
-  }
-}

package/src/errors/InvalidStringLengthError.ts

@@ -1,9 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidStringLengthError extends DomainError {
-  constructor(value: string, length: number) {
-    super(
-      `String length '${value.length}' exceeds the expected length: '${length}'`,
-    );
-  }
-}

package/src/errors/InvalidTimestampIntervalError.ts

@@ -1,10 +0,0 @@
-import { Timestamp } from '../value-objects/time/Timestamp';
-import { DomainError } from './DomainError';
-
-export class InvalidTimestampIntervalError extends DomainError {
-  constructor(start: Timestamp, end: Timestamp) {
-    super(
-      `Invalid TimestampInterval, start (${start.valueOf()}) must be before the end (${end.valueOf()})`,
-    );
-  }
-}

package/src/errors/InvalidValueError.ts

@@ -1,7 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class InvalidValueError extends DomainError {
-  constructor(message: string = 'Invalid Value Error', value?: unknown) {
-    super(`${message} with value: '${value}'`);
-  }
-}

package/src/errors/NullObjectError.ts

@@ -1,8 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class NullObjectError extends DomainError {
-  constructor(message: string) {
-    super(`[NullObjectError]: ${message} is NullObject`);
-    Object.setPrototypeOf(this, NullObjectError.prototype);
-  }
-}

package/src/errors/ValueNotInEnumError.ts

@@ -1,9 +0,0 @@
-import { DomainError } from './DomainError';
-
-export class ValueNotInEnumError extends DomainError {
-  constructor(value: unknown, enumerate: unknown) {
-    super(
-      `${Object.values(enumerate as object).join(',')} enum does not include value: ${value}`,
-    );
-  }
-}

package/src/interfaces/PrimitiveOf.ts

@@ -1,5 +0,0 @@
-import { Primitive } from '../types/Primitive';
-
-export type PrimitiveOf<
-  T extends { toPrimitives(): Primitive | Record<string, Primitive> },
-> = ReturnType<T['toPrimitives']>;

package/src/interfaces/index.ts

@@ -1 +0,0 @@
-export * from './PrimitiveOf';

package/src/patterns/Assert.ts

@@ -1,15 +0,0 @@
-import { BaseError } from '../errors/BaseError';
-import { DomainError } from '../errors/DomainError';
-
-export type Errors = Error | BaseError | DomainError | string;
-
-export function assert(
-  condition: boolean | unknown | undefined,
-  error: string | Errors,
-): void {
-  if (condition) {
-    return;
-  }
-
-  throw typeof error === 'string' ? new DomainError(error) : error;
-}

package/src/patterns/index.ts

@@ -1 +0,0 @@
-export * from './Assert';

package/src/value-objects/Color.ts

@@ -1,39 +0,0 @@
-import { InvalidColorError } from '../errors/InvalidColorError';
-import { assert } from '../patterns/Assert';
-import { NullObject } from './NullObject';
-import { StringValueObject } from './StringValueObject';
-
-export class Color extends StringValueObject {
-  public static readonly RED = new Color('#FF0000');
-  public static readonly GREEN = new Color('#00FF00');
-  public static readonly BLUE = new Color('#0000FF');
-  public static readonly BLACK = new Color('#000000');
-  public static readonly WHITE = new Color('#FFFFFF');
-  public static readonly YELLOW = new Color('#FFFF00');
-  public static readonly CYAN = new Color('#00FFFF');
-  public static readonly MAGENTA = new Color('#FF00FF');
-  public static readonly ORANGE = new Color('#FFA500');
-  public static readonly PURPLE = new Color('#800080');
-  public static readonly PINK = new Color('#FFC0CB');
-  public static readonly BROWN = new Color('#A52A2A');
-
-  constructor(value: string | StringValueObject) {
-    super(value?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-
-    this.ensureIsValidColor();
-  }
-
-  private ensureIsValidColor(): void {
-    const hexColorPattern = /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/;
-
-    assert(hexColorPattern.test(this.value), new InvalidColorError(this.value));
-  }
-
-  public isEqual(other: Color): boolean {
-    return this.value.toLowerCase() === other?.toString().toLowerCase();
-  }
-}

package/src/value-objects/Email.ts

@@ -1,23 +0,0 @@
-import { InvalidEmailError } from '../errors/InvalidEmailError';
-import { assert } from '../patterns/Assert';
-import { NullObject } from './NullObject';
-import { StringValueObject } from './StringValueObject';
-
-export class Email extends StringValueObject {
-  constructor(value: string | StringValueObject) {
-    super(value?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-
-    this.ensureIsValidEmail(this.value);
-  }
-
-  private ensureIsValidEmail(value: string): void {
-    assert(
-      new RegExp(/^[\w+\-.]+@(?:[\w-]+\.)+[a-zA-Z]{2,13}$/).test(value),
-      new InvalidEmailError(value),
-    );
-  }
-}

package/src/value-objects/Enum.ts

@@ -1,31 +0,0 @@
-import { ValueNotInEnumError } from '../errors/ValueNotInEnumError';
-import { assert } from '../patterns/Assert';
-import { Primitive } from '../types';
-import { NullObject } from './NullObject';
-import { ValueObject } from './ValueObject';
-
-export abstract class Enum<
-  T extends Primitive = Primitive,
-> extends ValueObject<T> {
-  constructor(protected readonly value: T) {
-    super(value);
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-
-    this.ensureIsValidValue();
-  }
-
-  private ensureIsValidValue(): void {
-    const isValueInEnum = this.getValues().some((enumValue) =>
-      this.isEqual(enumValue),
-    );
-    assert(
-      isValueInEnum,
-      new ValueNotInEnumError(this.valueOf(), this.getValues()),
-    );
-  }
-
-  public abstract getValues(): T[];
-}

package/src/value-objects/Integer.ts

@@ -1,22 +0,0 @@
-import { InvalidIntegerError } from '../errors/InvalidIntegerError';
-import { assert } from '../patterns/Assert';
-import { NullObject } from './NullObject';
-import { NumberValueObject } from './NumberValueObject';
-
-export class Integer extends NumberValueObject {
-  constructor(value: number | NumberValueObject) {
-    super(value?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-    this.ensureIsInteger();
-  }
-
-  private ensureIsInteger(): void {
-    assert(
-      this.value.valueOf() % 1 === 0,
-      new InvalidIntegerError(this.value.valueOf()),
-    );
-  }
-}

package/src/value-objects/NullObject.ts

@@ -1,60 +0,0 @@
-import { NullObjectError } from '../errors/NullObjectError';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Constructor<T> = abstract new (...args: any[]) => T;
-type NullableObject = Nullable & Record<string, unknown>;
-interface Nullable {
-  isNullObject: boolean;
-  valueOf(): undefined;
-}
-
-export abstract class NullObject {
-  private static setFakeProps<T>(
-    nullObject: NullableObject,
-    klass: Constructor<T>,
-  ): void {
-    const visited = new Set<string>();
-    let proto = klass.prototype;
-
-    while (proto && proto !== Object.prototype) {
-      const props = Object.getOwnPropertyNames(proto);
-
-      for (const prop of props) {
-        if (
-          prop === 'constructor' ||
-          prop === 'isNullObject' ||
-          prop === 'valueOf' ||
-          visited.has(prop)
-        ) {
-          continue;
-        }
-
-        visited.add(prop);
-        // eslint-disable-next-line no-param-reassign
-        nullObject[prop] = () => {
-          throw new NullObjectError(klass.name);
-        };
-      }
-
-      proto = Object.getPrototypeOf(proto);
-    }
-
-    Object.setPrototypeOf(nullObject, NullObject.prototype);
-  }
-
-  public static new<T>(klass: Constructor<T>): T {
-    const nullObject: NullableObject = {
-      isNullObject: true,
-      valueOf: () => {
-        return undefined;
-      },
-    };
-    NullObject.setFakeProps(nullObject, klass);
-
-    return nullObject as T;
-  }
-
-  public static isNullObject(nullable: unknown): boolean {
-    return !!(nullable as NullableObject)?.isNullObject;
-  }
-}

package/src/value-objects/NumberValueObject.ts

@@ -1,56 +0,0 @@
-import { InvalidNumberError } from '../errors/InvalidNumberError';
-import { assert } from '../patterns/Assert';
-import { NullObject } from './NullObject';
-import { ValueObject } from './ValueObject';
-
-export class NumberValueObject extends ValueObject<number> {
-  constructor(value: number | NumberValueObject) {
-    super(value?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-
-    assert(this.isValidNumber(this.value), new InvalidNumberError(this.value));
-  }
-
-  private isValidNumber(value: number): boolean {
-    return !isNaN(value.valueOf());
-  }
-
-  public isZero(): boolean {
-    return this.value === 0;
-  }
-
-  public isGreaterThan(other: number | NumberValueObject): boolean {
-    return this.value > other.valueOf();
-  }
-
-  public isGreaterOrEqualThan(other: number | NumberValueObject): boolean {
-    return this.value >= other.valueOf();
-  }
-
-  public isLessThan(other: number | NumberValueObject): boolean {
-    return this.value < other.valueOf();
-  }
-
-  public isLessOrEqualThan(other: number | NumberValueObject): boolean {
-    return this.value <= other.valueOf();
-  }
-
-  public add(other: number | NumberValueObject): NumberValueObject {
-    return this.clone(this.value + other.valueOf());
-  }
-
-  public subtract(other: number | NumberValueObject): NumberValueObject {
-    return this.clone(this.value - other.valueOf());
-  }
-
-  public multiply(other: number | NumberValueObject): NumberValueObject {
-    return this.clone(this.value * other.valueOf());
-  }
-
-  public divide(other: number | NumberValueObject): NumberValueObject {
-    return this.clone(this.value / other.valueOf());
-  }
-}

package/src/value-objects/PositiveNumber.ts

@@ -1,20 +0,0 @@
-import { InvalidPositiveNumberError } from '../errors/InvalidPositiveNumberError';
-import { assert } from '../patterns/Assert';
-import { NullObject } from './NullObject';
-import { NumberValueObject } from './NumberValueObject';
-
-export class PositiveNumber extends NumberValueObject {
-  constructor(value: number | NumberValueObject) {
-    super(value?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-
-    this.ensureIsPositive(this.value);
-  }
-
-  private ensureIsPositive(value: number): void {
-    assert(value >= 0, new InvalidPositiveNumberError());
-  }
-}

package/src/value-objects/StringValueObject.ts

@@ -1,27 +0,0 @@
-import { InvalidStringLengthError } from '../errors/InvalidStringLengthError';
-import { assert } from '../patterns/Assert';
-import { NullObject } from './NullObject';
-import { ValueObject } from './ValueObject';
-
-export class StringValueObject extends ValueObject<string> {
-  constructor(value: string | StringValueObject, maxLength: number = 512) {
-    super(value?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-
-    this.ensureDoesNotExceedsMaxLength(maxLength);
-  }
-
-  private ensureDoesNotExceedsMaxLength(maxLength: number): void {
-    assert(
-      this.value.length <= maxLength,
-      new InvalidStringLengthError(this.value, maxLength),
-    );
-  }
-
-  public isEmpty(): boolean {
-    return !this.value;
-  }
-}

package/src/value-objects/ValueObject.ts

@@ -1,39 +0,0 @@
-import { Primitive, Nullish } from '../types';
-import { NullObject } from './NullObject';
-
-export abstract class ValueObject<T extends Primitive = Primitive> {
-  protected readonly value!: T;
-
-  constructor(value: T | Nullish) {
-    if (this.isNullish(value)) {
-      return NullObject.new(new.target);
-    }
-    this.value = value;
-  }
-
-  private isNullish(value: T | Nullish): value is null | undefined {
-    return value === null || value === undefined;
-  }
-
-  protected clone(value: T): this {
-    return new (this.constructor as new (value: Primitive) => this)(
-      this.isNullish(value) ? this.value : value,
-    ) as this;
-  }
-
-  public isEqual(other: unknown): boolean {
-    return this.value === other?.valueOf();
-  }
-
-  public isNotEqual(other: unknown): boolean {
-    return this.isEqual(other) === false;
-  }
-
-  public valueOf(): T {
-    return this.value;
-  }
-
-  public toString(): string {
-    return this.value!.toString();
-  }
-}

package/src/value-objects/coordinates/Coordinates.ts

@@ -1,30 +0,0 @@
-import { StringValueObject } from '../StringValueObject';
-import { Latitude } from './Latitude';
-import { Longitude } from './Longitude';
-
-export class Coordinates extends StringValueObject {
-  private latitude: Latitude;
-  private longitude: Longitude;
-
-  public static fromString(value: string): Coordinates {
-    const latitude = parseFloat(value.split(',')[0]);
-    const longitude = parseFloat(value.split(',')[1]);
-
-    return new Coordinates(latitude, longitude);
-  }
-
-  constructor(latitude: number | Latitude, longitude: number | Longitude) {
-    super(latitude?.valueOf() + ',' + longitude?.valueOf());
-
-    this.latitude = new Latitude(latitude.valueOf());
-    this.longitude = new Longitude(longitude.valueOf());
-  }
-
-  public getLatitude(): Latitude {
-    return this.latitude;
-  }
-
-  public getLongitude(): Longitude {
-    return this.longitude;
-  }
-}

package/src/value-objects/coordinates/Latitude.ts

@@ -1,22 +0,0 @@
-import { InvalidLatitudeError } from '../../errors/InvalidLatitudeError';
-import { assert } from '../../patterns/Assert';
-import { NumberValueObject } from '../NumberValueObject';
-
-export class Latitude extends NumberValueObject {
-  private static MIN_VALUE = new NumberValueObject(-90);
-  private static MAX_VALUE = new NumberValueObject(90);
-
-  private static isValid(value: number | NumberValueObject): boolean {
-    const numberValue = new NumberValueObject(value.valueOf());
-
-    return (
-      numberValue.isGreaterOrEqualThan(this.MIN_VALUE) &&
-      numberValue.isLessOrEqualThan(this.MAX_VALUE)
-    );
-  }
-
-  constructor(value: number | NumberValueObject) {
-    super(value.valueOf());
-    assert(Latitude.isValid(value), new InvalidLatitudeError(value.valueOf()));
-  }
-}