@haskou/value-objects 1.1.0 → 1.1.2

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

@@ -1,25 +0,0 @@
-import { InvalidLongitudeError } from '../../errors/InvalidLongitudeError';
-import { assert } from '../../patterns/Assert';
-import { NumberValueObject } from '../NumberValueObject';
-
-export class Longitude extends NumberValueObject {
-  private static MIN_VALUE = new NumberValueObject(-180);
-  private static MAX_VALUE = new NumberValueObject(180);
-
-  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(
-      Longitude.isValid(value),
-      new InvalidLongitudeError(value.valueOf()),
-    );
-  }
-}

package/src/value-objects/hashes/Hash.ts

@@ -1,19 +0,0 @@
-import { NullObject } from '../NullObject';
-import { StringValueObject } from '../StringValueObject';
-import { ValueObject } from '../ValueObject';
-
-export abstract class Hash extends ValueObject<string> {
-  constructor(source: string | StringValueObject) {
-    super(source?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-  }
-
-  public toBase64(): StringValueObject {
-    return new StringValueObject(
-      Buffer.from(this.valueOf(), 'hex').toString('base64'),
-    );
-  }
-}

package/src/value-objects/hashes/MD5Hash.ts

@@ -1,32 +0,0 @@
-import crypto from 'node:crypto';
-
-import { InvalidHashError } from '../../errors/InvalidHashError';
-import { assert } from '../../patterns';
-import { NullObject } from '../NullObject';
-import { StringValueObject } from '../StringValueObject';
-import { Hash } from './Hash';
-
-export class MD5Hash extends Hash {
-  public static isValid(hash: string | StringValueObject): boolean {
-    return !!hash.valueOf().match(/^[a-f0-9]{32}$/);
-  }
-
-  public static from(buffer: Buffer | string | StringValueObject): MD5Hash {
-    return new MD5Hash(
-      crypto.createHash('md5').update(buffer.valueOf()).digest('hex'),
-    );
-  }
-
-  constructor(source: string | StringValueObject) {
-    super(source?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-
-    assert(
-      MD5Hash.isValid(this.valueOf()),
-      new InvalidHashError('MD5', source.valueOf()),
-    );
-  }
-}

package/src/value-objects/hashes/SHA256Hash.ts

@@ -1,38 +0,0 @@
-import { createHash } from 'crypto';
-
-import { InvalidHashError } from '../../errors/InvalidHashError';
-import { assert } from '../../patterns';
-import { NullObject } from '../NullObject';
-import { StringValueObject } from '../StringValueObject';
-import { ValueObject } from '../ValueObject';
-
-export class SHA256Hash extends ValueObject<string> {
-  public static isValid(hash: string | StringValueObject): boolean {
-    return !!hash.valueOf().match(/^[a-f0-9]{64}$/i);
-  }
-
-  public static from(buffer: Buffer | string | StringValueObject): SHA256Hash {
-    return new SHA256Hash(
-      createHash('sha256').update(buffer.valueOf()).digest('hex'),
-    );
-  }
-
-  constructor(source: string | StringValueObject) {
-    super(source?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-
-    assert(
-      SHA256Hash.isValid(this.valueOf()),
-      new InvalidHashError('SHA256', source.valueOf()),
-    );
-  }
-
-  public toBase64(): StringValueObject {
-    return new StringValueObject(
-      Buffer.from(this.valueOf(), 'hex').toString('base64'),
-    );
-  }
-}

package/src/value-objects/hashes/SHA512Hash.ts

@@ -1,38 +0,0 @@
-import { createHash } from 'crypto';
-
-import { InvalidHashError } from '../../errors/InvalidHashError';
-import { assert } from '../../patterns';
-import { NullObject } from '../NullObject';
-import { StringValueObject } from '../StringValueObject';
-import { ValueObject } from '../ValueObject';
-
-export class SHA512Hash extends ValueObject<string> {
-  public static isValid(hash: string | StringValueObject): boolean {
-    return !!hash.valueOf().match(/^[a-f0-9]{128}$/i);
-  }
-
-  public static from(buffer: Buffer | string | StringValueObject): SHA512Hash {
-    return new SHA512Hash(
-      createHash('sha512').update(buffer.valueOf()).digest('hex'),
-    );
-  }
-
-  constructor(source: string | StringValueObject) {
-    super(source?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-
-    assert(
-      SHA512Hash.isValid(this.valueOf()),
-      new InvalidHashError('SHA512', source.valueOf()),
-    );
-  }
-
-  public toBase64(): StringValueObject {
-    return new StringValueObject(
-      Buffer.from(this.valueOf(), 'hex').toString('base64'),
-    );
-  }
-}

package/src/value-objects/ids/ShortId.ts

@@ -1,34 +0,0 @@
-import ObjectId from 'bson-objectid';
-
-import { InvalidFormatError } from '../../errors/InvalidFormatError';
-import { InvalidLengthError } from '../../errors/InvalidLengthError';
-import { assert } from '../../patterns';
-import { NullObject } from '../NullObject';
-import { StringValueObject } from '../StringValueObject';
-import { ValueObject } from '../ValueObject';
-
-export class ShortId extends ValueObject<string> {
-  private static readonly LENGTH = 24;
-  private static readonly PATTERN = new RegExp(`[a-zA-Z0-9]{${this.LENGTH}}$`);
-
-  public static generate(): ShortId {
-    return new ShortId(ObjectId().toHexString());
-  }
-
-  constructor(value: string | StringValueObject) {
-    super(value?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-    this.ensureIsShortId(this.value);
-  }
-
-  private ensureIsShortId(value: string): void {
-    assert(
-      value.length === ShortId.LENGTH,
-      new InvalidLengthError(this.value, ShortId.LENGTH),
-    );
-    assert(ShortId.PATTERN.test(value), new InvalidFormatError(this.value));
-  }
-}

package/src/value-objects/ids/UUID.ts

@@ -1,34 +0,0 @@
-import { v4 } from 'uuid';
-
-import { InvalidFormatError } from '../../errors/InvalidFormatError';
-import { InvalidLengthError } from '../../errors/InvalidLengthError';
-import { assert } from '../../patterns';
-import { NullObject } from '../NullObject';
-import { StringValueObject } from '../StringValueObject';
-import { ValueObject } from '../ValueObject';
-
-export class UUID extends ValueObject<string> {
-  private static readonly LENGTH = 36;
-  private static readonly PATTERN = new RegExp(`^[a-z0-9-]{${this.LENGTH}}$`);
-
-  public static generate(): UUID {
-    return new UUID(v4());
-  }
-
-  constructor(value: string | StringValueObject) {
-    super(value?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-    this.ensureIsUUID(this.value);
-  }
-
-  private ensureIsUUID(value: string): void {
-    assert(
-      value.length === UUID.LENGTH,
-      new InvalidLengthError(this.value, UUID.LENGTH),
-    );
-    assert(UUID.PATTERN.test(value), new InvalidFormatError(this.value));
-  }
-}

package/src/value-objects/time/CalendarDay.ts

@@ -1,91 +0,0 @@
-import { InvalidDayError } from '../../errors/InvalidDayError';
-import { InvalidDayFormatError } from '../../errors/InvalidDayFormatError';
-import { assert } from '../../patterns/Assert';
-import { ValueObject } from '../ValueObject';
-import { Day } from './Day';
-import { DayOfWeek } from './DayOfWeek';
-import { Month } from './Month';
-import { MonthOfYear } from './MonthOfYear';
-import { Timestamp } from './Timestamp';
-
-export class CalendarDay extends ValueObject<string> {
-  private readonly year: number;
-  private readonly month: number;
-  private readonly day: number;
-
-  private static ensureIsValidValue(
-    value: string | Date | number | Timestamp,
-  ): void {
-    if (typeof value == 'string') {
-      this.ensureIsValidString(value);
-    }
-    this.ensureIsValidDate(new Date(value.valueOf()));
-  }
-
-  private static ensureIsValidString(value: string): void {
-    assert(
-      value.match(/^\d{4}-\d{1,2}-\d{1,2}$/),
-      new InvalidDayFormatError(value),
-    );
-  }
-
-  private static generateStringValue(timestamp: Timestamp): string {
-    const paddedMonth = timestamp.getMonth().toString().padStart(2, '0');
-    const paddedDay = timestamp.getDay().toString().padStart(2, '0');
-
-    return `${timestamp.getYear().toString()}-${paddedMonth}-${paddedDay}`;
-  }
-
-  private static ensureIsValidDate(value: Date | number | Timestamp): void {
-    assert(!isNaN(value.valueOf()), new InvalidDayError(value));
-  }
-
-  constructor(value?: string | Date | number | Timestamp) {
-    let timestamp: Timestamp;
-
-    if (value) {
-      CalendarDay.ensureIsValidValue(value);
-      timestamp = new Timestamp(value);
-    } else {
-      timestamp = new Timestamp();
-    }
-
-    super(CalendarDay.generateStringValue(timestamp));
-
-    this.year = timestamp.getYear().valueOf();
-    this.month = timestamp.getMonth().getIndex() + 1;
-    this.day = timestamp.getDay().valueOf();
-  }
-
-  public isAfter(date: CalendarDay): boolean {
-    return this.valueOf() > date.valueOf();
-  }
-
-  public isBefore(date: CalendarDay): boolean {
-    return this.valueOf() < date.valueOf();
-  }
-
-  public getYear(): number {
-    return this.year;
-  }
-
-  public getMonth(): Month {
-    return new Month(this.month);
-  }
-
-  public getMonthOfYear(): MonthOfYear {
-    return new MonthOfYear(this.month, this.year);
-  }
-
-  public getDay(): Day {
-    return new Day(this.day);
-  }
-
-  public getDayOfWeek(): DayOfWeek {
-    return DayOfWeek.fromNumber(this.toTimestamp().getDayOfWeek());
-  }
-
-  public toTimestamp(): Timestamp {
-    return new Timestamp(Date.UTC(this.year, this.month - 1, this.day));
-  }
-}

package/src/value-objects/time/Day.ts

@@ -1,17 +0,0 @@
-import { InvalidDayError } from '../../errors/InvalidDayError';
-import { assert } from '../../patterns/Assert';
-import { Integer } from '../Integer';
-import { NumberValueObject } from '../NumberValueObject';
-
-export class Day extends Integer {
-  constructor(value: number | NumberValueObject) {
-    super(value.valueOf());
-
-    this.ensureIsValidDay();
-  }
-
-  private ensureIsValidDay(): void {
-    assert(this.isGreaterOrEqualThan(1), new InvalidDayError(this.value));
-    assert(this.isLessOrEqualThan(31), new InvalidDayError(this.value));
-  }
-}

package/src/value-objects/time/DayOfWeek.ts

@@ -1,60 +0,0 @@
-import { InvalidDayError } from '../../errors/InvalidDayError';
-import { Enum } from '../Enum';
-import { Timestamp } from './Timestamp';
-
-export enum EDaysOfWeek {
-  MONDAY = 'monday',
-  TUESDAY = 'tuesday',
-  WEDNESDAY = 'wednesday',
-  THURSDAY = 'thursday',
-  FRIDAY = 'friday',
-  SATURDAY = 'saturday',
-  SUNDAY = 'sunday',
-}
-
-export const timeStampDayToDaysMap = {
-  [EDaysOfWeek.FRIDAY]: 5,
-  [EDaysOfWeek.MONDAY]: 1,
-  [EDaysOfWeek.SATURDAY]: 6,
-  [EDaysOfWeek.SUNDAY]: 0,
-  [EDaysOfWeek.THURSDAY]: 4,
-  [EDaysOfWeek.TUESDAY]: 2,
-  [EDaysOfWeek.WEDNESDAY]: 3,
-};
-
-export class DayOfWeek extends Enum {
-  public static MONDAY = new DayOfWeek(EDaysOfWeek.MONDAY);
-  public static TUESDAY = new DayOfWeek(EDaysOfWeek.TUESDAY);
-  public static WEDNESDAY = new DayOfWeek(EDaysOfWeek.WEDNESDAY);
-  public static THURSDAY = new DayOfWeek(EDaysOfWeek.THURSDAY);
-  public static FRIDAY = new DayOfWeek(EDaysOfWeek.FRIDAY);
-  public static SATURDAY = new DayOfWeek(EDaysOfWeek.SATURDAY);
-  public static SUNDAY = new DayOfWeek(EDaysOfWeek.SUNDAY);
-
-  public static fromNumber(day: number): DayOfWeek {
-    const [eDay] =
-      Object.entries(timeStampDayToDaysMap).find(
-        ([, value]) => value === day,
-      ) || [];
-
-    if (!eDay) {
-      throw new InvalidDayError(eDay);
-    }
-
-    return new DayOfWeek(eDay);
-  }
-
-  public static fromTimestamp(timestamp: Timestamp): DayOfWeek {
-    const dayOfWeekNumber = timestamp.getDayOfWeek();
-
-    return DayOfWeek.fromNumber(dayOfWeekNumber);
-  }
-
-  public getValues(): string[] {
-    return Object.values(EDaysOfWeek);
-  }
-
-  public toNumber(): number {
-    return timeStampDayToDaysMap[this.value as EDaysOfWeek];
-  }
-}

package/src/value-objects/time/Duration.ts

@@ -1,142 +0,0 @@
-import { NumberValueObject } from '../NumberValueObject';
-
-export class Duration extends NumberValueObject {
-  private static readonly MILLISECOND_FACTOR = 1000;
-  private static readonly SECOND_UNITS = {
-    DAYS: 24 * 60 * 60,
-    HOURS: 60 * 60,
-    MINUTES: 60,
-    MONTHS: 30 * 24 * 60 * 60,
-    SECONDS: 1,
-    WEEKS: 7 * 24 * 60 * 60,
-    YEARS: 365 * 24 * 60 * 60,
-  };
-
-  private static readonly millisecondFactors = {
-    DAYS: new NumberValueObject(
-      this.SECOND_UNITS.DAYS * this.MILLISECOND_FACTOR,
-    ),
-    HOURS: new NumberValueObject(
-      this.SECOND_UNITS.HOURS * this.MILLISECOND_FACTOR,
-    ),
-    MINUTES: new NumberValueObject(
-      this.SECOND_UNITS.MINUTES * this.MILLISECOND_FACTOR,
-    ),
-    MONTHS: new NumberValueObject(
-      this.SECOND_UNITS.MONTHS * this.MILLISECOND_FACTOR,
-    ),
-    SECONDS: new NumberValueObject(
-      this.SECOND_UNITS.SECONDS * this.MILLISECOND_FACTOR,
-    ),
-    WEEKS: new NumberValueObject(
-      this.SECOND_UNITS.WEEKS * this.MILLISECOND_FACTOR,
-    ),
-    YEARS: new NumberValueObject(
-      this.SECOND_UNITS.YEARS * this.MILLISECOND_FACTOR,
-    ),
-  };
-
-  public static fromDays(days: number | NumberValueObject): Duration {
-    return new Duration(
-      new NumberValueObject(days.valueOf()).multiply(
-        this.millisecondFactors.DAYS,
-      ),
-    );
-  }
-
-  public static fromHours(hours: number | NumberValueObject): Duration {
-    return new Duration(
-      new NumberValueObject(hours.valueOf()).multiply(
-        this.millisecondFactors.HOURS,
-      ),
-    );
-  }
-
-  public static fromMinutes(minutes: number | NumberValueObject): Duration {
-    return new Duration(
-      new NumberValueObject(minutes.valueOf()).multiply(
-        this.millisecondFactors.MINUTES,
-      ),
-    );
-  }
-
-  public static fromSeconds(seconds: number | NumberValueObject): Duration {
-    return new Duration(
-      new NumberValueObject(seconds.valueOf()).multiply(
-        this.millisecondFactors.SECONDS,
-      ),
-    );
-  }
-
-  public static fromMilliseconds(
-    milliseconds: number | NumberValueObject,
-  ): Duration {
-    return new Duration(new NumberValueObject(milliseconds.valueOf()));
-  }
-
-  constructor(milliseconds: NumberValueObject | Duration) {
-    super(milliseconds.valueOf());
-  }
-
-  public getTotalDays(): NumberValueObject {
-    return new Duration(this).divide(Duration.millisecondFactors.DAYS);
-  }
-
-  public getTotalHours(): NumberValueObject {
-    return new Duration(this).divide(Duration.millisecondFactors.HOURS);
-  }
-
-  public getTotalMinutes(): NumberValueObject {
-    return new Duration(this).divide(Duration.millisecondFactors.MINUTES);
-  }
-
-  public getTotalSeconds(): NumberValueObject {
-    return new Duration(this).divide(Duration.millisecondFactors.SECONDS);
-  }
-
-  public getTotalMilliseconds(): NumberValueObject {
-    return new NumberValueObject(this.valueOf());
-  }
-
-  public getDays(): NumberValueObject {
-    return new NumberValueObject(
-      Math.floor(
-        new Duration(this).divide(Duration.millisecondFactors.DAYS).valueOf(),
-      ) % Duration.SECOND_UNITS.DAYS,
-    );
-  }
-
-  public getHours(): NumberValueObject {
-    return new NumberValueObject(
-      Math.floor(
-        new Duration(this).divide(Duration.millisecondFactors.HOURS).valueOf(),
-      ) % Duration.SECOND_UNITS.HOURS,
-    );
-  }
-
-  public getMinutes(): NumberValueObject {
-    return new NumberValueObject(
-      Math.floor(
-        new Duration(this)
-          .divide(Duration.millisecondFactors.MINUTES)
-          .valueOf(),
-      ) % Duration.SECOND_UNITS.MINUTES,
-    );
-  }
-
-  public getSeconds(): NumberValueObject {
-    return new NumberValueObject(
-      Math.floor(
-        new Duration(this)
-          .divide(Duration.millisecondFactors.SECONDS)
-          .valueOf(),
-      ) % Duration.SECOND_UNITS.MINUTES,
-    );
-  }
-
-  public getMilliseconds(): NumberValueObject {
-    return new NumberValueObject(
-      Math.floor(new Duration(this).valueOf()) % Duration.MILLISECOND_FACTOR,
-    );
-  }
-}

package/src/value-objects/time/Hour.ts

@@ -1,105 +0,0 @@
-import { InvalidHourError } from '../../errors/InvalidHourError';
-import { InvalidMinutesError } from '../../errors/InvalidMinutesError';
-import { assert } from '../../patterns/Assert';
-import { StringValueObject } from '../StringValueObject';
-
-export class Hour extends StringValueObject {
-  private readonly minutes: string;
-  private readonly hours: string;
-  private static addTrailZero(value: string): string {
-    return Number(value) < 10 ? `0${Number(value)}` : value;
-  }
-
-  constructor(value: string);
-  constructor(value: number, minutes?: number);
-  constructor(value: string | number, minutes?: number) {
-    let parsedHours: string;
-    let parsedMinutes: string;
-
-    if (typeof value === 'number' && minutes !== undefined) {
-      assert(Number(value) >= 0 && Number(value) <= 23, new InvalidHourError());
-      assert(
-        Number(minutes) >= 0 && Number(minutes) <= 59,
-        new InvalidMinutesError(),
-      );
-
-      parsedHours = Hour.addTrailZero(value.toString());
-      parsedMinutes = Hour.addTrailZero(minutes.toString());
-    } else {
-      assert(typeof value === 'string', new InvalidHourError());
-      assert((value as string).includes(':'), new InvalidHourError());
-      const [hours, minutes] = (value as string).split(':');
-
-      assert(Number(hours) >= 0 && Number(hours) <= 23, new InvalidHourError());
-      assert(
-        Number(minutes) >= 0 && Number(minutes) <= 59,
-        new InvalidMinutesError(),
-      );
-      parsedHours = Hour.addTrailZero(hours);
-      parsedMinutes = Hour.addTrailZero(minutes);
-    }
-
-    super(`${parsedHours}:${parsedMinutes}`);
-    this.hours = parsedHours;
-    this.minutes = parsedMinutes;
-  }
-
-  public addMinutes(minutes: number): Hour {
-    const totalMinutes = Number(this.minutes) + minutes;
-    let newHour = Number(this.hours) + Math.floor(totalMinutes / 60);
-    let newMinutes = totalMinutes % 60;
-
-    if (newHour > 23) {
-      newHour = newHour - 24;
-    } else if (newHour < 0) {
-      newHour = 24 + newHour;
-    }
-
-    if (newMinutes < 0) {
-      newMinutes = 60 + newMinutes;
-    }
-
-    return new Hour(`${newHour}:${newMinutes}`);
-  }
-
-  public diffInMinutes(other: Hour): number {
-    let endHour = Number(other.hours);
-
-    if (
-      other.hours < this.hours ||
-      (other.hours === this.hours && other.minutes < this.minutes)
-    ) {
-      endHour += 24;
-    }
-
-    const totalMinutes =
-      (endHour - Number(this.hours)) * 60 +
-      (Number(other.minutes) - Number(this.minutes));
-
-    return totalMinutes;
-  }
-
-  public getMinutes(): number {
-    return Number(this.minutes);
-  }
-
-  public getHours(): number {
-    return Number(this.hours);
-  }
-
-  public isGreaterThan(hour: Hour): boolean {
-    if (this.hours === hour.hours) {
-      return Number(this.minutes) > Number(hour.minutes);
-    }
-
-    return Number(this.hours) > Number(hour.hours);
-  }
-
-  public isLessThan(hour: Hour): boolean {
-    if (this.hours === hour.hours) {
-      return Number(this.minutes) < Number(hour.minutes);
-    }
-
-    return Number(this.hours) < Number(hour.hours);
-  }
-}

package/src/value-objects/time/Month.ts

@@ -1,39 +0,0 @@
-import { Enum } from '../Enum';
-
-enum MonthEnum {
-  JANUARY = 1,
-  FEBRUARY = 2,
-  MARCH = 3,
-  APRIL = 4,
-  MAY = 5,
-  JUNE = 6,
-  JULY = 7,
-  AUGUST = 8,
-  SEPTEMBER = 9,
-  OCTOBER = 10,
-  NOVEMBER = 11,
-  DECEMBER = 12,
-}
-
-export class Month extends Enum<number> {
-  public static readonly JANUARY = new Month(MonthEnum.JANUARY);
-  public static readonly FEBRUARY = new Month(MonthEnum.FEBRUARY);
-  public static readonly MARCH = new Month(MonthEnum.MARCH);
-  public static readonly APRIL = new Month(MonthEnum.APRIL);
-  public static readonly MAY = new Month(MonthEnum.MAY);
-  public static readonly JUNE = new Month(MonthEnum.JUNE);
-  public static readonly JULY = new Month(MonthEnum.JULY);
-  public static readonly AUGUST = new Month(MonthEnum.AUGUST);
-  public static readonly SEPTEMBER = new Month(MonthEnum.SEPTEMBER);
-  public static readonly OCTOBER = new Month(MonthEnum.OCTOBER);
-  public static readonly NOVEMBER = new Month(MonthEnum.NOVEMBER);
-  public static readonly DECEMBER = new Month(MonthEnum.DECEMBER);
-
-  public getValues(): number[] {
-    return Object.values(MonthEnum) as number[];
-  }
-
-  public getIndex(): number {
-    return Number(this.valueOf()) - 1;
-  }
-}