@schorts/shared-kernel 4.2.1 → 4.2.3

package/__tests__/http/http-provider.test.ts

@@ -1,55 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { HTTPProvider } from "../../src/http";
-
-describe('HTTPProvider', () => {
-  describe('#get', () => {
-    it('should receive an URL', () => {
-      expectTypeOf<HTTPProvider["get"]>().parameters.toEqualTypeOf<[URL]>();
-    });
-
-    it('should return a Promise<ResponseType>', () => {
-      expectTypeOf<HTTPProvider["get"]>().returns.toEqualTypeOf<Promise<unknown>>();
-    });
-  });
-
-  describe('#post', () => {
-    it('should receive an URL and a body', () => {
-      expectTypeOf<HTTPProvider["post"]>().parameters.toEqualTypeOf<[URL, unknown]>();
-    });
-
-    it('should return a Promise<ResponseType>', () => {
-      expectTypeOf<HTTPProvider["post"]>().returns.toEqualTypeOf<Promise<unknown>>();
-    });
-  });
-
-  describe('#put', () => {
-    it('should receive an URL and a body', () => {
-      expectTypeOf<HTTPProvider["put"]>().parameters.toEqualTypeOf<[URL, unknown]>();
-    });
-
-    it('should return a Promise<ResponseType>', () => {
-      expectTypeOf<HTTPProvider["put"]>().returns.toEqualTypeOf<Promise<unknown>>();
-    });
-  });
-
-  describe('#patch', () => {
-    it('should receive an URL and a body', () => {
-      expectTypeOf<HTTPProvider["patch"]>().parameters.toEqualTypeOf<[URL, unknown]>();
-    });
-
-    it('should return a Promise<ResponseType>', () => {
-      expectTypeOf<HTTPProvider["patch"]>().returns.toEqualTypeOf<Promise<unknown>>();
-    });
-  });
-
-  describe('#delete', () => {
-    it('should receive an URL', () => {
-      expectTypeOf<HTTPProvider["delete"]>().parameters.toEqualTypeOf<[URL]>();
-    });
-
-    it('should return a Promise<ResponseType>', () => {
-      expectTypeOf<HTTPProvider["delete"]>().returns.toEqualTypeOf<Promise<unknown>>();
-    });
-  });
-});

package/__tests__/json-api/json-api-connector.test.ts

@@ -1,78 +0,0 @@
-import { JSONAPIConnector } from "../../src/json-api";
-import { Criteria } from "../../src/criteria";
-import type { HTTPProvider } from "../../src/http";
-
-describe("JSONAPIConnector", () => {
-  const base = new URL("https://api.example.com/users");
-  let http: jest.Mocked<HTTPProvider>;
-  let connector: JSONAPIConnector;
-
-  beforeEach(() => {
-    http = {
-      get: jest.fn(),
-      post: jest.fn(),
-      patch: jest.fn(),
-      put: jest.fn(),
-      delete: jest.fn(),
-    };
-    connector = new JSONAPIConnector(http);
-  });
-
-  it("calls findOne with correct URL and criteria", async () => {
-    const criteria = new Criteria().where("status", "EQUAL", "active");
-    const include = ["roles"];
-
-    await connector.findOne(base, criteria, include);
-
-    expect(http.get).toHaveBeenCalledWith(expect.any(URL));
-
-    const calledUrl = http.get.mock.calls[0][0];
-    
-    expect(calledUrl.searchParams.get("filter[status]")).toBe("active");
-    expect(calledUrl.href).toContain("include=roles");
-  });
-
-  it("calls findMany with sorting and pagination", async () => {
-    const criteria = new Criteria()
-      .orderBy("createdAt", "DESC")
-      .limitResults(10)
-      .offsetResults(20);
-
-    await connector.findMany(base, criteria);
-
-    const calledUrl = http.get.mock.calls[0][0];
-
-    expect(calledUrl.href).toContain("sort=-createdAt");
-    expect(calledUrl.searchParams.get("page[limit]")).toBe("10");
-    expect(calledUrl.searchParams.get("page[offset]")).toBe("20");
-  });
-
-  it("calls create with correct payload", async () => {
-    const payload = {
-      type: "users",
-      attributes: { name: "Jorge", email: "jorge@example.com" },
-    };
-
-    await connector.create(base, payload);
-
-    expect(http.post).toHaveBeenCalledWith(base, { data: payload });
-  });
-
-  it("calls update with correct payload", async () => {
-    const payload = {
-      id: "123",
-      type: "users",
-      attributes: { name: "Jorge Updated" },
-    };
-
-    await connector.update(base, payload);
-
-    expect(http.patch).toHaveBeenCalledWith(base, { data: payload });
-  });
-
-  it("calls delete with correct URL", async () => {
-    await connector.delete(base);
-
-    expect(http.delete).toHaveBeenCalledWith(base);
-  });
-});

package/__tests__/json-api/json-api-list.test.ts

@@ -1,24 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { JSONAPIList } from "../../src/json-api";
-import { BaseModel } from "../../src/models";
-
-type ExpectedJSONAPIList<EntityAttributes> = {
-  data: Array<{
-    id: string;
-    type: string;
-    attributes: Omit<EntityAttributes, "id">;
-  }>;
-  included?: Array<{
-    id: string;
-    type: string;
-    attributes: Record<string, any>;
-  }>;
-  meta?: Record<string, any>;
-};
-
-describe('JSONAPIList', () => {
-  it('should match the expected schema', () => {
-    expectTypeOf<JSONAPIList<BaseModel>>().toEqualTypeOf<ExpectedJSONAPIList<BaseModel>>()
-  });
-});

package/__tests__/json-api/json-api-single.test.ts

@@ -1,24 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { JSONAPISingle } from "../../src/json-api";
-import { BaseModel } from "../../src/models";
-
-type ExpectedJSONAPISingle<EntityAttributes> = {
-  data: {
-    id: string;
-    type: string;
-    attributes: Omit<EntityAttributes, "id">;
-  };
-  included?: Array<{
-    id: string;
-    type: string;
-    attributes: Omit<Record<string, any>, "id">;
-  }>;
-  meta?: Record<string, any>;
-};
-
-describe('JSONAPISingle', () => {
-  it('should match the expected schema', () => {
-    expectTypeOf<JSONAPISingle<BaseModel>>().toEqualTypeOf<ExpectedJSONAPISingle<BaseModel>>()
-  });
-});

package/__tests__/json-api/url-criteria-builder.test.ts

@@ -1,74 +0,0 @@
-import { URLCriteriaBuilder } from "../../src/json-api";
-import { Criteria } from "../../src/criteria";
-
-const base = new URL("https://api.example.com/resources");
-
-describe("URLCriteriaBuilder", () => {
-  it("encodes EQUAL filters as filter[field]=value", () => {
-    const criteria = new Criteria().where("status", "EQUAL", "active");
-    const url = new URLCriteriaBuilder(base, criteria).build();
-
-    expect(url.searchParams.get("filter[status]")).toBe("active");
-  });
-
-  it("encodes IN filters as comma-separated values", () => {
-    const criteria = new Criteria().where("role", "IN", ["admin", "editor"]);
-    const url = new URLCriteriaBuilder(base, criteria).build();
-
-    expect(url.searchParams.get("filter[role]")).toBe("admin,editor");
-  });
-
-  it("encodes other operators as filter[field][operator]=value", () => {
-    const criteria = new Criteria().where("createdAt", "GREATER_THAN", "2023-01-01");
-    const url = new URLCriteriaBuilder(base, criteria).build();
-
-    expect(url.searchParams.get("filter[createdAt][GREATER_THAN]")).toBe("2023-01-01");
-  });
-
-  it("supports nested filters using dot notation", () => {
-    const criteria = new Criteria().where("roles.name", "EQUAL", "admin");
-    const url = new URLCriteriaBuilder(base, criteria).build();
-
-    expect(url.searchParams.get("filter[roles.name]")).toBe("admin");
-  });
-
-  it("encodes sorting correctly", () => {
-    const criteria = new Criteria()
-      .orderBy("createdAt", "DESC")
-      .orderBy("name", "ASC");
-    const url = new URLCriteriaBuilder(base, criteria).build();
-
-    expect(url.searchParams.get("sort")).toBe("-createdAt,name");
-  });
-
-  it("encodes pagination correctly", () => {
-    const criteria = new Criteria().limitResults(20).offsetResults(40);
-    const url = new URLCriteriaBuilder(base, criteria).build();
-
-    expect(url.searchParams.get("page[limit]")).toBe("20");
-    expect(url.searchParams.get("page[offset]")).toBe("40");
-  });
-
-  it("adds include parameters", () => {
-    const url = new URLCriteriaBuilder(base, undefined, ["roles", "permissions"]).build();
-
-    expect(url.searchParams.getAll("include")).toEqual(["roles", "permissions"]);
-  });
-
-  it("builds full query with filters, sort, pagination, and includes", () => {
-    const criteria = new Criteria()
-      .where("status", "EQUAL", "active")
-      .where("roles.name", "EQUAL", "admin")
-      .orderBy("createdAt", "DESC")
-      .limitResults(10)
-      .offsetResults(30);
-    const url = new URLCriteriaBuilder(base, criteria, ["roles"]).build();
-
-    expect(url.searchParams.get("filter[status]")).toBe("active");
-    expect(url.searchParams.get("filter[roles.name]")).toBe("admin");
-    expect(url.searchParams.get("sort")).toBe("-createdAt");
-    expect(url.searchParams.get("page[limit]")).toBe("10");
-    expect(url.searchParams.get("page[offset]")).toBe("30");
-    expect(url.searchParams.getAll("include")).toEqual(["roles"]);
-  });
-});

package/__tests__/messages/message.test.ts

@@ -1,16 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { Message } from "../../src/messages";
-
-type MessagePrimitives = {
-  id: string;
-};
-
-describe("Message", () => {
-  it('should declare a "toPrimitives" method', () => {
-    expectTypeOf<Message>().toHaveProperty('toPrimitives');
-    expectTypeOf<Message['toPrimitives']>().toBeFunction();
-    expectTypeOf<Message<MessagePrimitives>['toPrimitives']>().returns.toEqualTypeOf<MessagePrimitives>();
-  });
-});
-

package/__tests__/models/base-model.test.ts

@@ -1,10 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { BaseModel } from "../../src/models";
-
-describe("BaseModel", () => {
-  it('should have a "id" property of type string or number', () => {
-    expectTypeOf<BaseModel>().toHaveProperty("id");
-    expectTypeOf<BaseModel['id']>().toEqualTypeOf<string | number>();
-  });
-});

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

@@ -1,101 +0,0 @@
-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__/unit-of-work/unit-of-work.test.ts

@@ -1,47 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { UnitOfWork } from "../../src/unit-of-work";
-
-describe("UnitOfWork", () => {
-  describe('#begin', () => {
-    it('should declare the method', () => {
-      expectTypeOf<UnitOfWork>().toHaveProperty("begin");
-    });
-
-    it('should no require any arguments', () => {
-      expectTypeOf<UnitOfWork['begin']>().parameters.toEqualTypeOf<[]>();
-    });
-
-    it('should return a promise', () => {
-      expectTypeOf<UnitOfWork['begin']>().returns.toEqualTypeOf<Promise<void>>();
-    });
-  })
-
-  describe('#commit', () => {
-    it('should declare the method', () => {
-      expectTypeOf<UnitOfWork>().toHaveProperty("commit");
-    });
-
-    it('should no require any arguments', () => {
-      expectTypeOf<UnitOfWork['commit']>().parameters.toEqualTypeOf<[]>();
-    });
-
-    it('should return a promise', () => {
-      expectTypeOf<UnitOfWork['commit']>().returns.toEqualTypeOf<Promise<void>>();
-    });
-  })
-
-  describe('#rollback', () => {
-    it('should declare the method', () => {
-      expectTypeOf<UnitOfWork>().toHaveProperty("rollback");
-    });
-
-    it('should no require any arguments', () => {
-      expectTypeOf<UnitOfWork['rollback']>().parameters.toEqualTypeOf<[]>();
-    });
-
-    it('should return a promise', () => {
-      expectTypeOf<UnitOfWork['rollback']>().returns.toEqualTypeOf<Promise<void>>();
-    });
-  })
-});

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

@@ -1,39 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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();
-    });
-  });
-});