@schorts/shared-kernel 4.2.0 → 4.2.2

package/__tests__/criteria/order.test.ts

@@ -1,14 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { Order } from "../../src/criteria";
-
-type ExpectedOrder = {
-  field: string;
-  direction: "ASC" | "DESC" | "NONE";
-}
-
-describe('Order', () => {
-  it('should match the expected type', () => {
-    expectTypeOf<Order>().toEqualTypeOf<ExpectedOrder>();
-  });
-});

package/__tests__/dao/dao.test.ts

@@ -1,126 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { DAO } from "../../src/dao";
-import { Entity } from "../../src/entities";
-import { Criteria } from "../../src/criteria";
-import { UUIDValue } from "../../src/value-objects";
-import { UnitOfWork } from "../../src/unit-of-work";
-
-type Model = {
-  id: string;
-  name: string;
-};
-
-class IDValue extends UUIDValue {
-  attributeName = "ID";
-}
-
-class ModelEntity extends Entity<IDValue, Model> {
-  constructor(id: IDValue) {
-    super(id);
-  }
-
-  toPrimitives(): Model {
-    throw new Error("Method not implemented.");
-  }
-}
-
-describe("DAO", () => {
-  describe('#getAll', () => {
-    it('should declare the method', () => {
-      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("getAll");
-    });
-
-    it('should no require any arguments', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['getAll']>().parameters.toEqualTypeOf<[]>();
-    });
-
-    it('should return a promise with the Entity', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['getAll']>().returns.toEqualTypeOf<Promise<ModelEntity[]>>();
-    });
-  });
-
-  describe('#findByID', () => {
-    it('should declare the method', () => {
-      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("findByID");
-    });
-
-    it('should require the ID argument', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['findByID']>().parameters.toEqualTypeOf<[ModelEntity["id"]["value"]]>();
-    });
-
-    it('should return a promise with the Entity or null', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['findByID']>().returns.toEqualTypeOf<Promise<ModelEntity | null>>();
-    });
-  });
-
-  describe('#findOneBy', () => {
-    it('should declare the method', () => {
-      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("findOneBy");
-    });
-
-    it('should receive the criteria', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['findOneBy']>().parameters.toEqualTypeOf<[Criteria]>();
-    });
-
-    it('should return a promise with the Entity or null', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['findOneBy']>().returns.toEqualTypeOf<Promise<ModelEntity | null>>();
-    });
-  });
-
-  describe('#search', () => {
-    it('should declare the method', () => {
-      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("search");
-    });
-
-    it('should receive the criteria argument', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['search']>().parameters.toEqualTypeOf<[Criteria]>();
-    });
-
-    it('should return a promise with an array of entities', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['search']>().returns.toEqualTypeOf<Promise<ModelEntity[]>>();
-    });
-  });
-
-  describe('#create', () => {
-    it('should declare the method', () => {
-      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("create");
-    });
-
-    it('should receive the entity and can receive a UnitOfWork', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['create']>().parameters.toEqualTypeOf<[ModelEntity, UnitOfWork?]>();
-    });
-
-    it('should return a promise with the created entity', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['create']>().returns.toEqualTypeOf<Promise<ModelEntity>>();
-    });
-  });
-
-  describe('#update', () => {
-    it('should declare the method', () => {
-      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("update");
-    });
-
-    it('should receive the entity and can receive a UnitOfWork', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['update']>().parameters.toEqualTypeOf<[ModelEntity, UnitOfWork?]>();
-    });
-
-    it('should return a promise with the updated entity', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['update']>().returns.toEqualTypeOf<Promise<ModelEntity>>();
-    });
-  });
-
-  describe('#delete', () => {
-    it('should declare the method', () => {
-      expectTypeOf<DAO<Model, ModelEntity>>().toHaveProperty("delete");
-    });
-
-    it('should receive the entity and can receive a UnitOfWork', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['delete']>().parameters.toEqualTypeOf<[ModelEntity, UnitOfWork?]>();
-    });
-
-    it('should return a promise with the deleted entity', () => {
-      expectTypeOf<DAO<Model, ModelEntity>['delete']>().returns.toEqualTypeOf<Promise<ModelEntity>>();
-    });
-  });
-});

package/__tests__/domain-events/domain-event-primitives.test.ts

@@ -1,34 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { DomainEventPrimitives } from "../../src/domain-events";
-
-describe("DomainEventPrimitives", () => {
-  it('should have a "id" property of type string', () => {
-    expectTypeOf<DomainEventPrimitives>().toHaveProperty('id');
-    expectTypeOf<DomainEventPrimitives['id']>().toBeString();
-  });
-
-  it('should have a "occurred_at" property of type string', () => {
-    expectTypeOf<DomainEventPrimitives>().toHaveProperty('occurred_at');
-    expectTypeOf<DomainEventPrimitives['occurred_at']>().toBeString();
-  });
-
-  it('should have a "type" property of type string', () => {
-    expectTypeOf<DomainEventPrimitives>().toHaveProperty('type');
-    expectTypeOf<DomainEventPrimitives['type']>().toBeString();
-  });
-
-  it('should have a "version" property of type number', () => {
-    expectTypeOf<DomainEventPrimitives>().toHaveProperty('version');
-    expectTypeOf<DomainEventPrimitives['version']>().toBeNumber();
-  });
-
-  it('should have a "payload" property of type number', () => {
-    type PayloadSchema = {
-      name: string;
-    };
-
-    expectTypeOf<DomainEventPrimitives<PayloadSchema>>().toHaveProperty('payload');
-    expectTypeOf<DomainEventPrimitives<PayloadSchema>['payload']>().toEqualTypeOf<PayloadSchema>();
-  });
-});

package/__tests__/domain-events/domain-event.test.ts

@@ -1,50 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { DomainEvent, DomainEventPrimitives } from "../../src/domain-events";
-
-describe('DomainEvent', () => {
-  it('should have a "id" property of type string', () => {
-    expectTypeOf<DomainEvent>().toHaveProperty("id");
-    expectTypeOf<DomainEvent['id']>().toBeString();
-  });
-
-  it('should have a "occurredAt" property of type Date', () => {
-    expectTypeOf<DomainEvent>().toHaveProperty("occurredAt");
-    expectTypeOf<DomainEvent['occurredAt']>().toEqualTypeOf<Date>();
-  });
-
-  it('should have a "type" property of type string', () => {
-    expectTypeOf<DomainEvent>().toHaveProperty("type");
-    expectTypeOf<DomainEvent['type']>().toBeString();
-  });
-
-  it('should have a "version" property of type number', () => {
-    expectTypeOf<DomainEvent>().toHaveProperty("version");
-    expectTypeOf<DomainEvent['version']>().toBeNumber();
-  });
-
-  it('should have a "payload" property of customt type', () => {
-    type PayloadSchema = {
-      name: string;
-    };
-
-    expectTypeOf<DomainEvent<PayloadSchema>>().toHaveProperty("payload");
-    expectTypeOf<DomainEvent<PayloadSchema>['payload']>().toEqualTypeOf<PayloadSchema>();
-  });
-
-  it('should have a "getEventName" method that returns an string', () => {
-    expectTypeOf<DomainEvent>().toHaveProperty('getEventName');
-    expectTypeOf<DomainEvent['getEventName']>().toBeFunction();
-    expectTypeOf<DomainEvent['getEventName']>().returns.toBeString();
-  });
-
-  it('should declare a "toPrimitives" method', () => {
-    type PayloadSchema = {
-      name: string;
-    };
-
-    expectTypeOf<DomainEvent>().toHaveProperty('toPrimitives');
-    expectTypeOf<DomainEvent['toPrimitives']>().toBeFunction();
-    expectTypeOf<DomainEvent<PayloadSchema>['toPrimitives']>().returns.toEqualTypeOf<DomainEventPrimitives<PayloadSchema>>();
-  });
-});

package/__tests__/entities/entity-registry.test.ts

@@ -1,71 +0,0 @@
-import { EntityRegistry, Entity, EntityNotRegistered } from "../../src/entities";
-import { UUIDValue } from "../../src/value-objects";
-
-type MockModel = {
-  id: string;
-};
-
-class IDValue extends UUIDValue {
-  attributeName = 'ID';
-}
-
-class MockEntity extends Entity<IDValue, MockModel> {
-  constructor(id: IDValue) {
-    super(id);
-  }
-
-  toPrimitives(): MockModel {
-    return {
-      id: this.id.value,
-    };
-  }
-
-  static fromPrimitives<MockModel>(model: MockModel): MockEntity {
-    return new MockEntity(
-      new IDValue(model["id"]),
-    );
-  }
-}
-
-describe("EntityRegistry", () => {
-  const type = "mock";
-
-  beforeEach(() => {
-    (EntityRegistry as any).registry.clear();
-  });
-
-  it("registers an entity constructor", () => {
-    EntityRegistry.register(type, MockEntity);
-
-    const resolved = EntityRegistry.resolve(type);
-
-    expect(resolved).toBe(MockEntity);
-  });
-
-  it("resolves a registered entity constructor", () => {
-    EntityRegistry.register(type, MockEntity);
-
-    const resolved = EntityRegistry.resolve(type);
-
-    expect(resolved?.fromPrimitives).toBeDefined();
-  });
-
-  it("returns null for unregistered types", () => {
-    const resolved = EntityRegistry.resolve("unknown");
-
-    expect(resolved).toBeNull();
-  });
-
-  it("creates an entity from a registered constructor", () => {
-    EntityRegistry.register(type, MockEntity);
-
-    const entity = EntityRegistry.create(type, { id: '123', name: 'Jorge' });
-
-    expect(entity).toBeInstanceOf(MockEntity);
-    expect(entity.id.value).toEqual('123');
-  });
-
-  it("throws EntityNotRegistered for unknown type", () => {
-    expect(() => EntityRegistry.create("unknown", { id: '123' })).toThrow(EntityNotRegistered);
-  });
-});

package/__tests__/entities/entity.test.ts

@@ -1,114 +0,0 @@
-import { expectTypeOf } from "expect-type";
-
-import { Entity } from "../../src/entities";
-import { ValueObject, UUIDValue } from "../../src/value-objects";
-import { DomainEvent, DomainEventPrimitives } from "../../src/domain-events";
-
-type Model = {
-  id: string;
-  name: string;
-};
-
-class TestDomainEvent extends DomainEvent {
-  static eventName = "shared.v1.tests.test_domain";
-
-  toPrimitives(): DomainEventPrimitives<{}> {
-    return {
-      id: this.id,
-      occurred_at: this.occurredAt.toString(),
-      payload: this.payload,
-      type: this.type,
-      version: this.version,
-    };
-  }
- 
-  getEventName() {
-    return TestDomainEvent.eventName;
-  }
-}
-
-class IDValue extends UUIDValue {
-  readonly attributeName = "ID";
-}
-
-class TestEntity extends Entity<IDValue, Model> {
-  toPrimitives(): Model {
-    return {
-      id: this.id.toString(),
-      name: "test",
-    };
-  }
-}
-
-describe('Entity', () => {
-  it('should have a "id" property of type string', () => {
-    expectTypeOf<Entity<IDValue, Model>>().toHaveProperty("id");
-    expectTypeOf<Entity<IDValue, Model>["id"]>().toEqualTypeOf<IDValue>();
-  });
-
-  it('should have a private "domainEvents" property of type Array<DomainEvent>', () => {
-    expectTypeOf<Entity<IDValue, Model>["domainEvents"]>().toEqualTypeOf<DomainEvent[]>();
-  });
-
-  describe('#pullDomainEvents', () => {
-    let testEntity: TestEntity;
-
-    beforeEach(() => {
-      testEntity = new TestEntity(new IDValue(""))
-    });
-
-    it('should return an array of DomainEvent', () => {
-      const domainEvents = testEntity.pullDomainEvents();
-
-      expectTypeOf<typeof domainEvents>().toEqualTypeOf<DomainEvent[]>();
-    });
-
-    it('should return the record domain events', () => {
-      const testDomainEvent = new TestDomainEvent(
-        "",
-        new Date(),
-        "Test",
-        1,
-        {},
-      );
-
-      testEntity.recordDomainEvent(testDomainEvent);
-
-      const domainEvents = testEntity.pullDomainEvents();
-      const expectedDomainEvents = [testDomainEvent];
-
-      expect(domainEvents).toEqual(expectedDomainEvents);
-    });
-  });
-
-  describe('#recordDomainEvent', () => {
-    let testEntity: TestEntity;
-
-    beforeEach(() => {
-      testEntity = new TestEntity(new IDValue(""))
-    });
-
-    it('should record a domain events', () => {
-      const testDomainEvent = new TestDomainEvent(
-        "",
-        new Date(),
-        "Test",
-        1,
-        {},
-      );
-
-      testEntity.recordDomainEvent(testDomainEvent);
-
-      const domainEvents = testEntity.pullDomainEvents();
-      const expectedDomainEvents = [testDomainEvent];
-
-      expect(domainEvents).toEqual(expectedDomainEvents);
-    });
-  });
-
-  it('should declare a "toPrimitives" method', () => {
-    expectTypeOf<Entity<IDValue, Model>>().toHaveProperty('toPrimitives');
-    expectTypeOf<Entity<IDValue, Model>['toPrimitives']>().toBeFunction();
-    expectTypeOf<Entity<IDValue, Model>['toPrimitives']>().returns.toEqualTypeOf<Model>();
-  });
-});

package/__tests__/entities/register-entity.decorator.test.ts

@@ -1,54 +0,0 @@
-import { RegisterEntity, EntityRegistry, Entity, EntityNotRegistered } from "../../src/entities";
-import { UUIDValue } from "../../src/value-objects";
-
-type MockModel = {
-  id: string;
-};
-
-class ID extends UUIDValue {
-  attributeName = "id";
-}
-
-class MockEntity extends Entity<ID, MockModel> {
-  constructor(id: ID) {
-    super(id);
-  }
-
-  toPrimitives(): MockModel {
-    return {
-      id: this.id.value,
-    };
-  }
-
-  static fromPrimitives<MockModel>(model: MockModel): MockEntity {
-    return new MockEntity(new ID(model["id"]));
-  }
-}
-
-RegisterEntity("mock")(MockEntity);
-
-describe("RegisterEntity", () => {
-  beforeEach(() => {
-    (EntityRegistry as any).registry.clear();
-    RegisterEntity("mock")(MockEntity);
-  });
-
-  it("registers the entity constructor under the given type", () => {
-    const resolved = EntityRegistry.resolve<MockModel>("mock");
-    expect(resolved).toBe(MockEntity);
-  });
-
-  it("creates an entity instance from registered type", () => {
-    const model = { id: 'abc-123' };
-    const entity = EntityRegistry.create("mock", model);
-
-    expect(entity).toBeInstanceOf(MockEntity);
-    expect(entity.id.value).toBe("abc-123");
-  });
-
-  it("throws if trying to create an unregistered entity", () => {
-    const model = { id: '123' };
-
-    expect(() => EntityRegistry.create("unknown", model)).toThrow(EntityNotRegistered);
-  });
-});

package/__tests__/formatters/pascal-camel-to-snake.test.ts

@@ -1,19 +0,0 @@
-import { PascalCamelToSnake } from "../../src/formatters";
-
-describe('PascalCamelToSnake', () => {
-  describe('.format', () => {
-    it('should return a pascal case to snake case', () => {
-      const resultID = PascalCamelToSnake.format("ID");
-      const resultExampleDAO = PascalCamelToSnake.format("ExampleDAO");
-
-      expect(resultID).toEqual("id");
-      expect(resultExampleDAO).toEqual("example_dao");
-    });
-
-    it('should return a camel case to snake case', () => {
-      const resultAlgoClass = PascalCamelToSnake.format("algoClass");
-
-      expect(resultAlgoClass).toEqual("algo_class");
-    });
-  });
-});

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

@@ -1,155 +0,0 @@
-import { FetchHTTPProvider, HTTPException } from "../../src/http";
-
-const url = new URL("https://api.example.com/resource");
-
-function createMockResponse({
-  ok = true,
-  status = 200,
-  contentType = "application/json",
-  body = {},
-}: {
-  ok?: boolean;
-  status?: number;
-  contentType?: string;
-  body?: any;
-}): Promise<Response> {
-  return Promise.resolve({
-    ok,
-    status,
-    headers: {
-      get: (key: string) =>
-        key.toLowerCase() === "content-type" ? contentType : null,
-    },
-    json: async () => body,
-    text: async () => (typeof body === "string" ? body : JSON.stringify(body)),
-    blob: async () =>
-      new Blob([typeof body === "string" ? body : JSON.stringify(body)], {
-        type: contentType,
-      }),
-  } as unknown as Response);
-}
-
-describe("FetchHTTPProvider", () => {
-  let provider: FetchHTTPProvider;
-
-  beforeEach(() => {
-    provider = new FetchHTTPProvider();
-    global.fetch = jest.fn();
-  });
-
-  afterEach(() => {
-    jest.resetAllMocks();
-  });
-
-  it("parses JSON response", async () => {
-    const mockJson = { message: "success" };
-
-    (global.fetch as jest.Mock).mockImplementation(() =>
-      createMockResponse({ body: mockJson })
-    );
-
-    const result = await provider.get<typeof mockJson>(url);
-
-    expect(result).toEqual(mockJson);
-  });
-
-  it("parses text response", async () => {
-    const mockText = "plain text";
-
-    (global.fetch as jest.Mock).mockImplementation(() =>
-      createMockResponse({ contentType: "text/plain", body: mockText })
-    );
-
-    const result = await provider.get<string>(url);
-
-    expect(result).toEqual(mockText);
-  });
-
-  it("parses blob response", async () => {
-    const mockBinary = "image data";
-
-    (global.fetch as jest.Mock).mockImplementation(() =>
-      createMockResponse({ contentType: "image/png", body: mockBinary })
-    );
-
-    const result = await provider.get<Blob>(url);
-
-    expect(result).toBeInstanceOf(Blob);
-  });
-
-  it("returns undefined for 204 No Content", async () => {
-    (global.fetch as jest.Mock).mockImplementation(() =>
-      createMockResponse({ status: 204, body: undefined })
-    );
-
-    const result = await provider.get<undefined>(url);
-
-    expect(result).toBeUndefined();
-  });
-
-  it("throws HTTPException on failed JSON response", async () => {
-    const errorJson = { title: "Unauthorized", code: 401 };
-
-    (global.fetch as jest.Mock).mockImplementation(() =>
-      createMockResponse({ ok: false, status: 401, body: errorJson })
-    );
-
-    await expect(provider.get(url)).rejects.toThrow(HTTPException);
-  });
-
-  it("throws HTTPException on failed text response", async () => {
-    const errorText = "Forbidden";
-
-    (global.fetch as jest.Mock).mockImplementation(() =>
-      createMockResponse({
-        ok: false,
-        status: 403,
-        contentType: "text/plain",
-        body: errorText,
-      })
-    );
-
-    await expect(provider.get(url)).rejects.toThrow(HTTPException);
-  });
-
-  it("deduplicates ongoing requests", async () => {
-    const mockJson = { message: "deduplicated" };
-    
-    (global.fetch as jest.Mock).mockImplementation(() =>
-      createMockResponse({ body: mockJson })
-    );
-
-    const promise1 = provider.get<typeof mockJson>(url);
-    const promise2 = provider.get<typeof mockJson>(url);
-
-    expect(promise1).toStrictEqual(promise2);
-
-    const result = await promise1;
-
-    expect(result).toEqual(mockJson);
-    expect(global.fetch).toHaveBeenCalledTimes(1);
-  });
-
-  it("cleans up ongoingRequests after completion", async () => {
-    const mockJson = { message: "done" };
-
-    (global.fetch as jest.Mock).mockImplementation(() =>
-      createMockResponse({ body: mockJson })
-    );
-
-    await provider.get<typeof mockJson>(url);
-
-    const key = `GET:${url.href}:`;
-    const internalMap = (provider as any).ongoingRequests as Map<string, Promise<any>>;
-
-    expect(internalMap.has(key)).toBe(false);
-  });
-
-  it("throws if fetch returns undefined", async () => {
-    (global.fetch as jest.Mock).mockImplementation(() =>
-      Promise.resolve(undefined as any)
-    );    
-
-    await expect(provider.get(url)).rejects.toThrow(HTTPException);
-  });
-});