@haskou/value-objects 1.1.1 → 1.1.2

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

@@ -1,52 +0,0 @@
-import { ValueObject } from '../ValueObject';
-import { Month } from './Month';
-import { Timestamp } from './Timestamp';
-import { TimestampInterval } from './TimestampInterval';
-import { Year } from './Year';
-
-export class MonthOfYear extends ValueObject<string> {
-  private readonly month: Month;
-  private readonly year: Year;
-
-  public static fromTimestamp(timestamp: Timestamp): MonthOfYear {
-    return new MonthOfYear(timestamp.getMonth(), timestamp.getYear());
-  }
-
-  public static fromString(value: string): MonthOfYear {
-    const [year, month] = value.split('/').map(Number);
-
-    return new MonthOfYear(month, year);
-  }
-
-  constructor(month: number | Month, year: number | Year) {
-    super(
-      year.valueOf().toString() +
-        '/' +
-        month.valueOf().toString().padStart(2, '0'),
-    );
-    this.month = new Month(month.valueOf());
-    this.year = new Year(year.valueOf());
-  }
-
-  public getMonth(): Month {
-    return new Month(this.month.valueOf());
-  }
-
-  public getYear(): Year {
-    return new Year(this.year);
-  }
-
-  public getNumberOfDays(): number {
-    return new Date(this.year.valueOf(), this.month.valueOf(), 0).getDate();
-  }
-
-  public getTimestampInterval(): TimestampInterval {
-    const firstMonthDay = '01';
-    const month = this.month.valueOf().toString().padStart(2, '0');
-    const lastDay = this.getNumberOfDays().toString();
-    const startDate = new Timestamp(`${this.year}-${month}-${firstMonthDay}`);
-    const endDate = new Timestamp(`${this.year}-${month}-${lastDay}`);
-
-    return new TimestampInterval(startDate, endDate);
-  }
-}

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

@@ -1,208 +0,0 @@
-import { NumberValueObject } from '../NumberValueObject';
-import { ValueObject } from '../ValueObject';
-import { CalendarDay } from './CalendarDay';
-import { Day } from './Day';
-import { Duration } from './Duration';
-import { Month } from './Month';
-import { MonthOfYear } from './MonthOfYear';
-import { Year } from './Year';
-
-type TimestampValue = number | Date | Timestamp | string;
-
-export class Timestamp extends ValueObject<number> {
-  private static readonly FACTORS = {
-    DAYS: 24 * 60 * 60 * 1000,
-    HOURS: 60 * 60 * 1000,
-    MINUTES: 60 * 1000,
-    MONTHS: 30 * 24 * 60 * 60 * 1000,
-    SECONDS: 1000,
-    WEEKS: 7 * 24 * 60 * 60 * 1000,
-    YEARS: 365 * 24 * 60 * 60 * 1000,
-  };
-
-  private static valueMilliseconds(value?: TimestampValue): number {
-    if (value instanceof Timestamp || value instanceof Date) {
-      return value.valueOf();
-    }
-
-    if (typeof value === 'number') {
-      return value;
-    }
-
-    if (typeof value === 'string') {
-      return new Date(value).valueOf();
-    }
-
-    return Date.now().valueOf();
-  }
-
-  public static new(value: TimestampValue): Timestamp {
-    return new Timestamp(value);
-  }
-
-  public static now(): Timestamp {
-    return new Timestamp();
-  }
-
-  public static fromSeconds(seconds: number | NumberValueObject): Timestamp {
-    return new Timestamp(seconds.valueOf() * Timestamp.FACTORS.SECONDS);
-  }
-
-  public constructor(value?: TimestampValue) {
-    super(Timestamp.valueMilliseconds(value));
-  }
-
-  public toExactHour(): Timestamp {
-    const date = new Date(this.valueOf());
-
-    date.setSeconds(0);
-    date.setMinutes(0);
-    date.setMilliseconds(0);
-
-    const value = Timestamp.new(date.getTime()).value;
-
-    return this.clone(value);
-  }
-
-  public toMilliseconds(): number {
-    return this.value;
-  }
-
-  public toSeconds(): number {
-    return Math.round(this.value / Timestamp.FACTORS.SECONDS);
-  }
-
-  public toDate(): Date {
-    return new Date(this.value);
-  }
-
-  public toString(): string {
-    return `${this.valueOf()}`;
-  }
-
-  public isEqual(other: Timestamp): boolean {
-    return this.value === other.valueOf();
-  }
-
-  public isBefore(other: Timestamp): boolean {
-    return this.value < other.valueOf();
-  }
-
-  public isAfter(other: Timestamp): boolean {
-    return this.value > other.valueOf();
-  }
-
-  public isBeforeOrEqual(other: Timestamp): boolean {
-    return this.value <= other.valueOf();
-  }
-
-  public isAfterOrEqual(other: Timestamp): boolean {
-    return this.value >= other.valueOf();
-  }
-
-  public addMilliseconds(milliseconds: number | NumberValueObject): Timestamp {
-    const value = this.value + milliseconds.valueOf();
-
-    return this.clone(value);
-  }
-
-  public addSeconds(seconds: number | NumberValueObject): Timestamp {
-    const value = this.value + seconds.valueOf() * Timestamp.FACTORS.SECONDS;
-
-    return this.clone(value);
-  }
-
-  public addMinutes(minutes: number | NumberValueObject): Timestamp {
-    const value = this.value + minutes.valueOf() * Timestamp.FACTORS.MINUTES;
-
-    return this.clone(value);
-  }
-
-  public addHours(hours: number | NumberValueObject): Timestamp {
-    const value = this.value + hours.valueOf() * Timestamp.FACTORS.HOURS;
-
-    return this.clone(value);
-  }
-
-  public addDays(days: number | NumberValueObject): Timestamp {
-    const value = this.value + days.valueOf() * Timestamp.FACTORS.DAYS;
-
-    return this.clone(value);
-  }
-
-  public addWeeks(weeks: number | NumberValueObject): Timestamp {
-    const value = this.value + weeks.valueOf() * Timestamp.FACTORS.WEEKS;
-
-    return this.clone(value);
-  }
-
-  public addMonths(months: number | NumberValueObject): Timestamp {
-    const value = this.value + months.valueOf() * Timestamp.FACTORS.MONTHS;
-
-    return this.clone(value);
-  }
-
-  public addYears(years: number | NumberValueObject): Timestamp {
-    const value = this.value + years.valueOf() * Timestamp.FACTORS.YEARS;
-
-    return this.clone(value);
-  }
-
-  public addDuration(duration: Duration): Timestamp {
-    const value = this.value + duration.valueOf();
-
-    return this.clone(value);
-  }
-
-  public isSameDay(other: Timestamp): boolean {
-    return this.getCalendarDay().isEqual(other.getCalendarDay());
-  }
-
-  public isSameMonth(other: Timestamp): boolean {
-    return this.getMonthOfYear().isEqual(other.getMonthOfYear());
-  }
-
-  public isSameYear(other: Timestamp): boolean {
-    return this.getYear().isEqual(other.getYear());
-  }
-
-  public getCalendarDay(): CalendarDay {
-    return new CalendarDay(this);
-  }
-
-  public getDay(): Day {
-    return new Day(this.toDate().getUTCDate());
-  }
-
-  public getMonth(): Month {
-    return new Month(this.toDate().getUTCMonth() + 1);
-  }
-
-  public getYear(): Year {
-    return new Year(this.toDate().getUTCFullYear());
-  }
-
-  public getHours(): number {
-    return this.toDate().getUTCHours();
-  }
-
-  public getMinutes(): number {
-    return this.toDate().getUTCMinutes();
-  }
-
-  public getSeconds(): number {
-    return this.toDate().getUTCSeconds();
-  }
-
-  public getMilliseconds(): number {
-    return this.toDate().getUTCMilliseconds();
-  }
-
-  public getDayOfWeek(): number {
-    return this.toDate().getUTCDay();
-  }
-
-  public getMonthOfYear(): MonthOfYear {
-    return new MonthOfYear(this.getMonth(), this.getYear());
-  }
-}

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

@@ -1,122 +0,0 @@
-import { InvalidTimestampIntervalError } from '../../errors/InvalidTimestampIntervalError';
-import { PrimitiveOf } from '../../interfaces/PrimitiveOf';
-import { assert } from '../../patterns/Assert';
-import { PositiveNumber } from '../PositiveNumber';
-import { ValueObject } from '../ValueObject';
-import { CalendarDay } from './CalendarDay';
-import { DayOfWeek } from './DayOfWeek';
-import { Duration } from './Duration';
-import { Timestamp } from './Timestamp';
-
-export class TimestampInterval extends ValueObject<string> {
-  public static fromPrimitives(
-    primitives: PrimitiveOf<TimestampInterval>,
-  ): TimestampInterval {
-    return new TimestampInterval(
-      new Timestamp(primitives.start),
-      new Timestamp(primitives.end),
-    );
-  }
-
-  constructor(
-    private start: Timestamp,
-    private end: Timestamp,
-  ) {
-    super(`${start.valueOf()}-${end.valueOf()}`);
-
-    assert(
-      start.isBeforeOrEqual(end),
-      new InvalidTimestampIntervalError(start, end),
-    );
-  }
-
-  public toPrimitives() {
-    return {
-      end: this.end.valueOf(),
-      start: this.start.valueOf(),
-    };
-  }
-
-  public getStart(): Timestamp {
-    return this.start;
-  }
-
-  public getEnd(): Timestamp {
-    return this.end;
-  }
-
-  public getDuration(): Duration {
-    return new Duration(
-      new PositiveNumber(this.end.valueOf() - this.start.valueOf()),
-    );
-  }
-
-  public getTotalDaysOfWeek(dayOfWeek: DayOfWeek): number {
-    const oneDayInMilliseconds = 24 * 60 * 60 * 1000;
-    const daysToCheck: number = Math.trunc(
-      this.getDuration().valueOf() / oneDayInMilliseconds,
-    );
-
-    let count = 0;
-
-    for (let daysChecked = 0; daysChecked <= daysToCheck; daysChecked++) {
-      const iteratorDay = new Timestamp(this.start).addDays(daysChecked);
-
-      if (iteratorDay.getDayOfWeek() === dayOfWeek.toNumber()) {
-        count++;
-      }
-    }
-
-    return count;
-  }
-
-  public modifyStart(start: Timestamp): void {
-    const end = this.end;
-    assert(start.isBefore(end), new InvalidTimestampIntervalError(start, end));
-    this.start = start;
-  }
-
-  public modifyEnd(end: Timestamp): void {
-    const start = this.start;
-    assert(start.isBefore(end), new InvalidTimestampIntervalError(start, end));
-    this.end = end;
-  }
-
-  public getDaysBetweenInterval(): CalendarDay[] {
-    const days: CalendarDay[] = [];
-
-    let iteratorTimestamp = new Timestamp(this.getStart());
-    const endTimestamp = new Timestamp(this.getEnd());
-
-    while (iteratorTimestamp.isBeforeOrEqual(endTimestamp)) {
-      days.push(new CalendarDay(iteratorTimestamp));
-      iteratorTimestamp = iteratorTimestamp.addDays(1);
-    }
-
-    return days;
-  }
-
-  public getOverlappingInterval(
-    searchInterval: TimestampInterval,
-  ): TimestampInterval | null {
-    const start = this.start.isAfter(searchInterval.getStart())
-      ? this.start
-      : searchInterval.getStart();
-    const end = this.end.isBefore(searchInterval.getEnd())
-      ? this.end
-      : searchInterval.getEnd();
-
-    if (start.isAfterOrEqual(end)) {
-      return null;
-    }
-
-    return new TimestampInterval(start, end);
-  }
-
-  public includes(timestamp: Timestamp): boolean {
-    return (
-      timestamp.isAfterOrEqual(this.start) &&
-      timestamp.isBeforeOrEqual(this.end)
-    );
-  }
-}

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

@@ -1,27 +0,0 @@
-import { Integer } from '../Integer';
-import { NullObject } from '../NullObject';
-import { NumberValueObject } from '../NumberValueObject';
-
-export class Year extends Integer {
-  private static readonly YEAR_DAYS = 365;
-  private static readonly LEAP_YEAR_DAYS = 366;
-
-  constructor(value: number | NumberValueObject) {
-    super(value?.valueOf());
-
-    if (NullObject.isNullObject(this)) {
-      return this;
-    }
-  }
-
-  public isLeapYear(): boolean {
-    return this.getNumberOfDays() === Year.LEAP_YEAR_DAYS;
-  }
-
-  public getNumberOfDays(): number {
-    return (this.value % 4 === 0 && this.value % 100 !== 0) ||
-      this.value % 400 === 0
-      ? Year.LEAP_YEAR_DAYS
-      : Year.YEAR_DAYS;
-  }
-}

package/tests/errors/BaseError.spec.ts

@@ -1,63 +0,0 @@
-import { BaseError } from '../../src/errors/BaseError';
-
-describe('BaseError', () => {
-  describe('constructor', () => {
-    it('should be valid instance', () => {
-      const error = new BaseError('this is an error');
-      expect(error).toBeInstanceOf(BaseError);
-    });
-
-    it('should be valid when value is a string', () => {
-      expect(new BaseError('this is an error').toString()).toInclude(
-        'this is an error',
-      );
-    });
-  });
-
-  describe('isBaseError', () => {
-    class TestBaseError extends BaseError {
-      constructor() {
-        super('test error');
-      }
-    }
-
-    it('should be true when error is a BaseError', () => {
-      const error = new BaseError('this is an error');
-      expect(BaseError.isBaseError(error)).toBeTrue();
-    });
-
-    it('should be false when error is not a BaseError', () => {
-      const error = new Error('this is an error');
-      expect(BaseError.isBaseError(error)).toBeFalse();
-    });
-
-    it('should be false when error param is not an error', () => {
-      expect(BaseError.isBaseError('')).toBeFalse();
-    });
-
-    it('should be true when error is a TestBaseError', () => {
-      const error = new TestBaseError();
-      expect(BaseError.isBaseError(error)).toBeTrue();
-    });
-  });
-
-  describe('toString', () => {
-    it('should return the error message', () => {
-      const error = new BaseError('this is an error');
-      expect(error.toString()).toInclude('this is an error');
-    });
-  });
-
-  describe('getStack', () => {
-    it('should return the error stack', () => {
-      const error = new BaseError('this is an error');
-      expect(error.getStack()).toInclude('this is an error');
-    });
-
-    it('should return empty stack', () => {
-      const error = new BaseError('this is an error');
-      delete error.stack;
-      expect(error.getStack()).toBeEmpty();
-    });
-  });
-});

package/tests/errors/DomainError.spec.ts

@@ -1,52 +0,0 @@
-/* eslint-disable no-unused-expressions */
-import { DomainError } from '../../src/errors/DomainError';
-
-describe('DomainError', () => {
-  describe('constructor', () => {
-    it('should be valid instance', () => {
-      const error = new DomainError('this is an error');
-      expect(error).toBeInstanceOf(DomainError);
-    });
-  });
-
-  describe('isDomainError', () => {
-    class TestDomainError extends DomainError {
-      constructor() {
-        super('test error');
-      }
-    }
-
-    it('should be true when error is a DomainError', () => {
-      const error = new DomainError('this is an error');
-      expect(DomainError.isDomainError(error)).toBeTrue();
-    });
-
-    it('should be false when error is not a DomainError', () => {
-      const error = new Error('this is an error');
-      expect(DomainError.isDomainError(error)).toBeFalse();
-    });
-
-    it('should be false when error param is not an error', () => {
-      expect(DomainError.isDomainError('')).toBeFalse();
-    });
-
-    it('should be true when error is a TestDomainError', () => {
-      const error = new TestDomainError();
-      expect(DomainError.isDomainError(error)).toBeTrue();
-    });
-  });
-
-  describe('toString', () => {
-    it('should return the error message', () => {
-      const error = new DomainError('this is an error');
-      expect(error.toString()).toInclude('this is an error');
-    });
-  });
-
-  describe('getStack', () => {
-    it('should return the error stack', () => {
-      const error = new DomainError('this is an error');
-      expect(error.getStack()).toInclude('this is an error');
-    });
-  });
-});

package/tests/patterns/Assert.spec.ts

@@ -1,29 +0,0 @@
-import { assert, DomainError } from '../../src';
-
-describe('Assert', () => {
-  it('should throw an error if the condition is false', () => {
-    expect(() => {
-      assert(false, 'Error');
-    }).toThrow('Error');
-  });
-
-  it('should not throw an error if the condition is true', () => {
-    expect(() => {
-      assert(true, 'Error');
-    }).not.toThrow();
-  });
-
-  it('should throw an error if the condition is false and the error is a function', () => {
-    expect(() => {
-      assert(false, new Error('Error'));
-    }).toThrow('Error');
-  });
-
-  it('should throw a domain error if the condition is false and the error is a string', () => {
-    expect(() => assert(false, 'Error')).toThrow(DomainError);
-  });
-
-  it('should throw if the condition is not a boolean', () => {
-    expect(() => assert(1, 'Error')).not.toThrow();
-  });
-});

package/tests/setup.jest.ts

@@ -1,2 +0,0 @@
-import * as matchers from 'jest-extended';
-expect.extend(matchers);