@schorts/shared-kernel 1.0.0

package/__tests__/state-manager/state-manager.test.ts

@@ -0,0 +1,101 @@
+import { expectTypeOf } from "expect-type";
+
+import { StateManager } from "../../src/state-manager";
+
+type Schema = {
+  name: string;
+};
+
+describe("StateManager", () => {
+  it('should have a "state" property of the provided Schema', () => {
+    expectTypeOf<StateManager<Schema>["state"]>().toEqualTypeOf<Schema>();
+  });
+
+  it('should have a "listeners" property of type Array<(state: Schema) => void>', () => {
+    expectTypeOf<StateManager<Schema>["listeners"]>().toEqualTypeOf<Array<(state: Schema) => void>>();
+  });
+
+  describe('#getValue', () => {
+    it('should define the function', () => {
+      expectTypeOf<StateManager<Schema>["getValue"]>().toBeFunction();
+    });
+
+    it('should receive a key of Schema', () => {
+      expectTypeOf<StateManager<Schema>["getValue"]>().parameters.toEqualTypeOf<[keyof Schema]>();
+    });
+
+    it('should return a Promise with a value from the Schema', () => {
+      expectTypeOf<StateManager<Schema>["getValue"]>().returns.toEqualTypeOf<Promise<Schema[keyof Schema]>>();
+    });
+  });
+
+  describe('#setValue', () => {
+    it('should define the function', () => {
+      expectTypeOf<StateManager<Schema>["setValue"]>().toBeFunction();
+    });
+
+    it('should receive a key of Schema and the value to set', () => {
+      expectTypeOf<StateManager<Schema>["setValue"]>().parameters.toEqualTypeOf<[keyof Schema, Schema[keyof Schema]]>();
+    });
+
+    it('should return a void Promise', () => {
+      expectTypeOf<StateManager<Schema>["setValue"]>().returns.toEqualTypeOf<Promise<void>>();
+    });
+  });
+
+  describe('#removeValue', () => {
+    it('should define the function', () => {
+      expectTypeOf<StateManager<Schema>["removeValue"]>().toBeFunction();
+    });
+
+    it('should receive a key of Schema', () => {
+      expectTypeOf<StateManager<Schema>["removeValue"]>().parameters.toEqualTypeOf<[keyof Schema]>();
+    });
+
+    it('should return a Promise with a value from the Schema', () => {
+      expectTypeOf<StateManager<Schema>["removeValue"]>().returns.toEqualTypeOf<Promise<void>>();
+    });
+  });
+
+  describe('#getState', () => {
+    it('should define the function', () => {
+      expectTypeOf<StateManager<Schema>["getState"]>().toBeFunction();
+    });
+
+    it('should receive no params', () => {
+      expectTypeOf<StateManager<Schema>["getState"]>().parameters.toEqualTypeOf<[]>();
+    });
+
+    it('should return the value with Schema as type', () => {
+      expectTypeOf<StateManager<Schema>["getState"]>().returns.toEqualTypeOf<Schema>();
+    });
+  });
+
+  describe('#subscribe', () => {
+    it('should define the function', () => {
+      expectTypeOf<StateManager<Schema>["subscribe"]>().toBeFunction();
+    });
+
+    it('should receive a function of type (state: Schema) => void', () => {
+      expectTypeOf<StateManager<Schema>["subscribe"]>().parameters.toEqualTypeOf<[(state: Schema) => void]>();
+    });
+
+    it('should return a void function', () => {
+      expectTypeOf<StateManager<Schema>["subscribe"]>().returns.toEqualTypeOf<() => void>();
+    });
+  });
+
+  describe('#notifyListeners', () => {
+    it('should define the function', () => {
+      expectTypeOf<StateManager<Schema>["notifyListeners"]>().toBeFunction();
+    });
+
+    it('should receive no params', () => {
+      expectTypeOf<StateManager<Schema>["notifyListeners"]>().parameters.toEqualTypeOf<[]>();
+    });
+
+    it('should return a void function', () => {
+      expectTypeOf<StateManager<Schema>["notifyListeners"]>().returns.toEqualTypeOf<void>();
+    });
+  });
+});

package/__tests__/utils/url/url-with-params-builder.test.ts

@@ -0,0 +1,39 @@
+import { expectTypeOf } from "expect-type";
+
+import { URLWithParamsBuilder } from "../../../src/utils";
+
+const baseURL = 'https://github.com/schorts';
+const url = new URL(baseURL);
+
+describe('URLWithParamsBuilder', () => {
+  it('should have a "base" property of type URL', () => {
+    expectTypeOf<URLWithParamsBuilder["base"]>().toEqualTypeOf<URL>();
+  });
+
+  describe('#with', () => {
+    it('should receive a params with type Record<string, string | number | boolean | string[] | number[]>', () => {
+      expectTypeOf<URLWithParamsBuilder["with"]>().parameters.toEqualTypeOf<[Record<string, string | number | boolean | string[] | number[]>]>();
+    });
+
+    it('should return the same instance', () => {
+      const uRLWithParamsBuilder = new URLWithParamsBuilder(url);
+      const result = uRLWithParamsBuilder.with({ page: 1 });
+
+      expect(result).toEqual(uRLWithParamsBuilder);
+    });
+  });
+
+  describe('#build', () => {
+    it('should receive no params', () => {
+      expectTypeOf<URLWithParamsBuilder["build"]>().parameters.toEqualTypeOf<[]>();
+    });
+
+    it('should return the updated url', () => {
+      const uRLWithParamsBuilder = new URLWithParamsBuilder(url);
+      const expectedURL = new URL(`${baseURL}?page=1`);
+      const result = uRLWithParamsBuilder.with({ page: 1 }).build();
+
+      expect(result.href).toEqual(expectedURL.href);
+    });
+  });
+});

package/__tests__/value-objects/coordinates-value.test.ts

@@ -0,0 +1,68 @@
+import { expectTypeOf } from "expect-type";
+
+import { ValueObject, CoordinatesValue } from "../../src/value-objects";
+
+class TestCoordinatesValue extends CoordinatesValue {
+  readonly attributeName = "test";
+}
+
+describe("CoordinatesValue", () => {
+  it('should implement "ValueObject" interface', () => {
+    expectTypeOf<CoordinatesValue>().toExtend<ValueObject>();
+  });
+
+  it('should have a "valueType" with "Coordinates" as value', () => {
+    const testCoordinatesValue = new TestCoordinatesValue({ latitude: 0, longitude: 0 });
+
+    expect(testCoordinatesValue.valueType).toEqual("Coordinates");
+  });
+
+  it('should have a "value" property of type { latitude: number, longitude: number }', () => {
+    expectTypeOf<CoordinatesValue["value"]>().toMatchObjectType<{ latitude: number, longitude: number }>();
+  });
+
+  it('should have a "latitude" property of type number or null', () => {
+    expectTypeOf<CoordinatesValue["latitude"]>().toEqualTypeOf<number | null>();
+  });
+
+  it('should have a "longitude" property of type number or null', () => {
+    expectTypeOf<CoordinatesValue["longitude"]>().toEqualTypeOf<number | null>();
+  });
+
+  it('should define the "equals" method', () => {
+    expectTypeOf<CoordinatesValue["equals"]>().toEqualTypeOf<(valueObject: unknown) => boolean>();
+  });
+
+  describe('when "value" is a valid coordinate', () => {
+    const coordinates = { latitude: 0, longitude: 0 };
+    const testCoordinatesValue = new TestCoordinatesValue(coordinates);
+
+    it('should return true the "isValid" getter', () => {
+      expect(testCoordinatesValue.isValid).toBeTruthy();
+    });
+
+    it('should return the latitude value', () => {
+      expect(testCoordinatesValue.latitude).toEqual(coordinates.latitude);
+    });
+
+    it('should return the longitude value', () => {
+      expect(testCoordinatesValue.longitude).toEqual(coordinates.longitude);
+    });
+  });
+
+  describe('when "value" is not a valid coordinate', () => {
+    const testCoordinatesValue = new TestCoordinatesValue({ latitude: -200, longitude: 500 });
+
+    it('should return false the "isValid" getter', () => {
+      expect(testCoordinatesValue.isValid).toBeFalsy();
+    });
+
+    it('should return null as the latitude value', () => {
+      expect(testCoordinatesValue.latitude).toBeNull();
+    });
+
+    it('should return null as the longitude value', () => {
+      expect(testCoordinatesValue.longitude).toBeNull();
+    });
+  });
+});

package/__tests__/value-objects/email-value.test.ts

@@ -0,0 +1,43 @@
+import { expectTypeOf } from "expect-type";
+
+import { ValueObject, EmailValue } from "../../src/value-objects";
+
+class TestEmailValue extends EmailValue {
+  readonly attributeName = "test";
+}
+
+describe("EmailValue", () => {
+  it('should implement "ValueObject" interface', () => {
+    expectTypeOf<EmailValue>().toExtend<ValueObject>();
+  });
+
+  it('should have a "valueType" with "Email" as value', () => {
+    const testEmailValue = new TestEmailValue("");
+
+    expect(testEmailValue.valueType).toEqual("Email");
+  });
+
+  it('should have a "value" property of type string', () => {
+    expectTypeOf<EmailValue["value"]>().toBeString();
+  });
+
+  it('should define the "equals" method', () => {
+    expectTypeOf<EmailValue["equals"]>().toEqualTypeOf<(valueObject: unknown) => boolean>();
+  });
+
+  describe('when "value" is an email', () => {
+    it('should return true the "isValid" getter', () => {
+      const testEmailValue = new TestEmailValue("test@example.com");
+
+      expect(testEmailValue.isValid).toBeTruthy();
+    });
+  });
+
+  describe('when "value" is not an email', () => {
+    it('should return false the "isValid" getter', () => {
+      const testEmailValue = new TestEmailValue("test@com");
+
+      expect(testEmailValue.isValid).toBeFalsy();
+    });
+  });
+});

package/__tests__/value-objects/enum-value.test.ts

@@ -0,0 +1,51 @@
+import { expectTypeOf } from "expect-type";
+
+import { ValueObject, EnumValue } from "../../src/value-objects";
+
+class TestEnumValue extends EnumValue {
+  readonly attributeName = "test";
+}
+
+describe("EnumValue", () => {
+  it('should implement "ValueObject" interface', () => {
+    expectTypeOf<TestEnumValue>().toExtend<ValueObject>();
+  });
+
+  it('should have a "valueType" with "Enum" as value', () => {
+    const testEnumValue = new TestEnumValue([], "");
+
+    expect(testEnumValue.valueType).toEqual("Enum");
+  });
+
+  it('should have a "value" property of type string', () => {
+    expectTypeOf<EnumValue["value"]>().toBeString();
+  });
+
+  it('should have a "allowedValues" property of type string[]', () => {
+    expectTypeOf<EnumValue["allowedValues"]>().toBeArray();
+  });
+
+  it('should have a "allowedTypes" property of type string', () => {
+    expectTypeOf<EnumValue["attributeName"]>().toBeString;
+  });
+
+  it('should define the "equals" method', () => {
+    expectTypeOf<EnumValue["equals"]>().toEqualTypeOf<(valueObject: unknown) => boolean>();
+  });
+
+  describe('when value is in the "allowedTypes" property', () => {
+    it('should return true on the "isValid" getter', () => {
+      const testEnumValue = new TestEnumValue(["test"], "test");
+
+      expect(testEnumValue.isValid).toBeTruthy();
+    });
+  });
+
+  describe('when value is not in the "allowedTypes" property', () => {
+    it('should return true on the "isValid" getter', () => {
+      const testEnumValue = new TestEnumValue(["test"], "test2");
+
+      expect(testEnumValue.isValid).toBeFalsy();
+    });
+  });
+});

package/__tests__/value-objects/integer-value.test.ts

@@ -0,0 +1,115 @@
+import { expectTypeOf } from "expect-type";
+
+import { ValueObject, IntegerValue } from "../../src/value-objects";
+
+class TestIntegerValue extends IntegerValue {
+  readonly attributeName = "test";
+}
+
+describe("IntegerValue", () => {
+  it('should implement "ValueObject" interface', () => {
+    expectTypeOf<IntegerValue>().toExtend<ValueObject>();
+  });
+
+  it('should have a "valueType" with "Integer" as value', () => {
+    const testIntegerValue = new TestIntegerValue(0);
+
+    expect(testIntegerValue.valueType).toEqual("Integer");
+  });
+
+  it('should have a "value" property of type number', () => {
+    expectTypeOf<IntegerValue["value"]>().toBeNumber();
+  });
+
+  it('should have a "min" property of type number or undefined', () => {
+    expectTypeOf<IntegerValue["min"]>().toEqualTypeOf<number | undefined>();
+  });
+
+  it('should have a "max" property of type number or undefined', () => {
+    expectTypeOf<IntegerValue["max"]>().toEqualTypeOf<number | undefined>()
+  });
+
+  it('should define the "equals" method', () => {
+    expectTypeOf<IntegerValue["equals"]>().toEqualTypeOf<(valueObject: unknown) => boolean>();
+  });
+
+  describe('when "min" is not present', () => {
+    it('should allow any negative integer as valid', () => {
+      const testIntegerValue = new TestIntegerValue(-1);
+
+      expect(testIntegerValue.isValid).toBeTruthy();
+    });
+  });
+
+  describe('when "min" is present', () => {
+    it('should assign the provided value', () => {
+      const min = 1;
+      const testIntegerValue = new TestIntegerValue(0, min);
+
+      expect(testIntegerValue.min).toEqual(min);
+    });
+
+    it('should return false if the value provided is less than the "min"', () => {
+      const min = 1;
+      const testIntegerValue = new TestIntegerValue(-1, min);
+
+      expect(testIntegerValue.isValid).toBeFalsy();
+    });
+
+    it('should return true if the value provided is greather or equal than the "min', () => {
+      const min = 1;
+      const testIntegerValue = new TestIntegerValue(1, min);
+
+      expect(testIntegerValue.isValid).toBeTruthy();
+    });
+  });
+
+  describe('when "max" is not present', () => {
+    it('should assign a default value of undefined', () => {
+      const testIntegerValue = new TestIntegerValue(0);
+
+      expect(testIntegerValue.max).toBeUndefined();
+    });
+  });
+
+  describe('when "max" is present', () => {
+    it('should assign the provided value', () => {
+      const max = 1;
+      const testIntegerValue = new TestIntegerValue(0, undefined, max);
+
+      expect(testIntegerValue.max).toEqual(max);
+    });
+
+    it('should return false if the value provided is greather than the "max"', () => {
+      const max = 1;
+      const testIntegerValue = new TestIntegerValue(2, undefined, max);
+
+      expect(testIntegerValue.isValid).toBeFalsy();
+    });
+
+    it('should return true if the value provided is less or equal than the "max', () => {
+      const max = 1;
+      const testIntegerValue = new TestIntegerValue(1, undefined, max);
+
+      expect(testIntegerValue.isValid).toBeTruthy();
+    });
+  });
+
+  describe('when "min" and "max" is present', () => {
+    it('should return false if the value provided is not between the "min" and "max"', () => {
+      const min = -1;
+      const max = 1;
+      const testIntegerValue = new TestIntegerValue(2, min, max);
+
+      expect(testIntegerValue.isValid).toBeFalsy();
+    });
+
+    it('should return true if the value provided is not between the "min" and "max"', () => {
+      const min = -1;
+      const max = 1;
+      const testIntegerValue = new TestIntegerValue(0, min, max);
+
+      expect(testIntegerValue.isValid).toBeTruthy();
+    });
+  });
+});

package/__tests__/value-objects/phone-value.test.ts

@@ -0,0 +1,82 @@
+import { expectTypeOf } from "expect-type";
+
+import { ValueObject, PhoneValue } from "../../src/value-objects";
+
+class TestPhoneValue extends PhoneValue {
+  readonly attributeName = "test";
+}
+
+describe("PhoneValue", () => {
+  it('should implement "ValueObject" interface', () => {
+    expectTypeOf<PhoneValue>().toExtend<ValueObject>();
+  });
+
+  it('should have a "valueType" with "Phone" as value', () => {
+    const testPhoneValue = new TestPhoneValue("");
+
+    expect(testPhoneValue.valueType).toEqual("Phone");
+  });
+
+  it('should have a "value" property of type string', () => {
+    expectTypeOf<PhoneValue["value"]>().toBeString();
+  });
+
+  it('should have a "countryCode" property of type string', () => {
+    expectTypeOf<PhoneValue["countryCode"]>().toEqualTypeOf<string | null>();
+  });
+
+  it('should have a "phoneNumber" property of type string', () => {
+    expectTypeOf<PhoneValue["phoneNumber"]>().toEqualTypeOf<string | null>();
+  });
+
+  it('should have a "formattedPhone" property of type string', () => {
+    expectTypeOf<PhoneValue["formattedPhone"]>().toEqualTypeOf<string | null>();
+  });
+
+  it('should define the "equals" method', () => {
+    expectTypeOf<PhoneValue["equals"]>().toEqualTypeOf<(valueObject: unknown) => boolean>();
+  });
+
+  describe('when "value" is a phone', () => {
+    const countryCode = "+52";
+    const phoneNumber = "1234567890";
+    const formattedPhone = `${countryCode} (123) 456-7890`;
+    const testPhoneValue = new TestPhoneValue(`${countryCode}${phoneNumber}`);
+
+    it('should return true the "isValid" getter', () => {
+      expect(testPhoneValue.isValid).toBeTruthy();
+    });
+
+    it('should return the "countryCode" property', () => {
+      expect(testPhoneValue.countryCode).toEqual(countryCode);
+    });
+
+    it('should return the "phoneNumber" property', () => {
+      expect(testPhoneValue.phoneNumber).toEqual(phoneNumber);
+    });
+
+    it('should return the "formattedPhone" property', () => {
+      expect(testPhoneValue.formattedPhone).toEqual(formattedPhone);
+    });
+  });
+
+  describe('when "value" is not a phone', () => {
+    const testPhoneValue = new TestPhoneValue("+112345678901241");
+
+    it('should return false the "isValid" getter', () => {
+      expect(testPhoneValue.isValid).toBeFalsy();
+    });
+
+    it('should return null for the "countryCode" property', () => {
+      expect(testPhoneValue.countryCode).toBeNull();
+    });
+
+    it('should return null for the "phoneNumber" property', () => {
+      expect(testPhoneValue.phoneNumber).toBeNull();
+    });
+
+    it('should return null for the "formattedPhone" property', () => {
+      expect(testPhoneValue.formattedPhone).toBeNull();
+    });
+  });
+});

package/__tests__/value-objects/slug-value.test.ts

@@ -0,0 +1,43 @@
+import { expectTypeOf } from "expect-type";
+
+import { ValueObject, SlugValue } from "../../src/value-objects";
+
+class TestSlugValue extends SlugValue {
+  readonly attributeName = "test";
+}
+
+describe("SlugValue", () => {
+  it('should implement "ValueObject" interface', () => {
+    expectTypeOf<TestSlugValue>().toExtend<ValueObject>();
+  });
+
+  it('should have a "valueType" with "Slug" as value', () => {
+    const testSlugValue = new TestSlugValue("");
+
+    expect(testSlugValue.valueType).toEqual("Slug");
+  });
+
+  it('should have a "value" property of type string', () => {
+    expectTypeOf<SlugValue["value"]>().toBeString();
+  });
+
+  it('should define the "equals" method', () => {
+    expectTypeOf<SlugValue["equals"]>().toEqualTypeOf<(valueObject: unknown) => boolean>();
+  });
+
+  describe('when "value" is an slug', () => {
+    it('should return true the "isValid" getter', () => {
+      const testSlugValue = new TestSlugValue("schorts");
+
+      expect(testSlugValue.isValid).toBeTruthy();
+    });
+  });
+
+  describe('when "value" is not an slug', () => {
+    it('should return false the "isValid" getter', () => {
+      const testSlugValue = new TestSlugValue("-schorts");
+
+      expect(testSlugValue.isValid).toBeFalsy();
+    });
+  });
+});

package/__tests__/value-objects/string-value.test.ts

@@ -0,0 +1,121 @@
+import { expectTypeOf } from "expect-type";
+
+import { ValueObject, StringValue } from "../../src/value-objects";
+
+class TestStringalue extends StringValue {
+  readonly attributeName = "test";
+}
+
+describe("StringValue", () => {
+  it('should implement "ValueObject" interface', () => {
+    expectTypeOf<TestStringalue>().toExtend<ValueObject>();
+  });
+
+  it('should have a "valueType" with "String" as value', () => {
+    const testStringValue = new TestStringalue("");
+
+    expect(testStringValue.valueType).toEqual("String");
+  });
+
+  it('should have a "value" property of type string', () => {
+    expectTypeOf<StringValue["value"]>().toBeString();
+  });
+
+  it('should have a "minLength" property of type number', () => {
+    expectTypeOf<StringValue["minLength"]>().toBeNumber();
+  });
+
+  it('should have a "maxLength" property of type number or undefined', () => {
+    expectTypeOf<StringValue["maxLength"]>().toEqualTypeOf<number | undefined>()
+  });
+
+  it('should define the "equals" method', () => {
+    expectTypeOf<StringValue["equals"]>().toEqualTypeOf<(valueObject: unknown) => boolean>();
+  });
+
+  describe('when "minLength" is not present', () => {
+    it('should assign a default value of 0', () => {
+      const testStringValue = new TestStringalue("");
+
+      expect(testStringValue.minLength).toEqual(0);
+    });
+
+    it('should allow an empty string as valid', () => {
+      const testStringValue = new TestStringalue("");
+
+      expect(testStringValue.isValid).toBeTruthy();
+    });
+  });
+
+  describe('when "minLength" is present', () => {
+    it('should assign the provided value', () => {
+      const minLength = 1;
+      const testStringValue = new TestStringalue("", minLength);
+
+      expect(testStringValue.minLength).toEqual(minLength);
+    });
+
+    it('should return false if the value provided length is less than the "minLength"', () => {
+      const minLength = 1;
+      const testStringValue = new TestStringalue("", minLength);
+
+      expect(testStringValue.isValid).toBeFalsy();
+    });
+
+    it('should return true if the value provided length is greather or equal than the "minLength', () => {
+      const minLength = 1;
+      const testStringValue = new TestStringalue("1", minLength);
+
+      expect(testStringValue.isValid).toBeTruthy();
+    });
+  });
+
+  describe('when "maxLength" is not present', () => {
+    it('should assign a default value of undefined', () => {
+      const testStringValue = new TestStringalue("");
+
+      expect(testStringValue.maxLength).toBeUndefined();
+    });
+  });
+
+  describe('when "maxLength" is present', () => {
+    it('should assign the provided value', () => {
+      const maxLength = 1;
+      const testStringValue = new TestStringalue("", 0, maxLength);
+
+      expect(testStringValue.maxLength).toEqual(maxLength);
+    });
+
+    it('should return false if the value provided length is greather than the "maxLength"', () => {
+      const maxLength = 1;
+      const testStringValue = new TestStringalue("12", 0, maxLength);
+
+      expect(testStringValue.isValid).toBeFalsy();
+    });
+
+    it('should return true if the value provided length is less or equal than the "maxLength', () => {
+      const maxLength = 2;
+      const testStringValue = new TestStringalue("1", 0, maxLength);
+
+      expect(testStringValue.isValid).toBeTruthy();
+    });
+  });
+
+  describe('when "minLength" and "maxLength" is present', () => {
+    it('should return false if the value provided length is not between the "minLength" and "maxLength"', () => {
+      const minLength = 1;
+      const maxLength = 2;
+      const testStringValue = new TestStringalue("123", minLength, maxLength);
+
+      expect(testStringValue.isValid).toBeFalsy();
+    });
+
+    it('should return true if the value provided length is not between the "minLength" and "maxLength"', () => {
+      const minLength = 1;
+      const maxLength = 2;
+      const testStringValue = new TestStringalue("12", minLength, maxLength);
+
+      expect(testStringValue.isValid).toBeTruthy();
+    });
+  });
+});