@sentzunhat/zacatl 0.0.13 → 0.0.20

package/test/unit/helpers/database/mongo.ts

@@ -1,77 +0,0 @@
-import { MongoMemoryServer } from "mongodb-memory-server";
-import { connect, Connection, Mongoose } from "mongoose";
-import { container } from "tsyringe";
-
-const dbName = "sentzunhat-zacatl";
-const dbVersion = "8.0.0";
-const dbStorageEngine = "wiredTiger";
-
-let mongoDBMemoryServer: MongoMemoryServer | null = null;
-
-let dbConnection: Connection | null = null;
-
-export const startMongoServerAndSetEnvConnectionString =
-  async (): Promise<void> => {
-    if (mongoDBMemoryServer) {
-      return;
-    }
-
-    try {
-      mongoDBMemoryServer = await MongoMemoryServer.create({
-        instance: {
-          dbName,
-          storageEngine: dbStorageEngine,
-        },
-        binary: {
-          version: dbVersion,
-        },
-      });
-
-      const mongoDBUri = mongoDBMemoryServer.getUri();
-      const connectionString = `${mongoDBUri}${dbName}`;
-
-      process.env["MONGO_DB_CONNECTION_STRING"] = connectionString;
-      //   console.info(
-      //     `MongoDB memory server started. Connection string set to: ${connectionString}`
-      //   );
-    } catch (error) {
-      //   console.error("Failed to start MongoDB memory server:", error);
-      throw error;
-    }
-  };
-
-export const connectToMongoServerAndRegisterDependency = async () => {
-  const connectionString = process.env["MONGO_DB_CONNECTION_STRING"] ?? "";
-  const dbName = "sentzunhat-zacatl";
-
-  try {
-    const conn = await connect(connectionString, {
-      dbName,
-      autoCreate: true,
-      autoIndex: true,
-    });
-
-    dbConnection = conn.connection;
-
-    container.register<Mongoose>(Mongoose, {
-      useValue: conn,
-    });
-
-    // logger.info("Mongo DB memory server connected");
-  } catch (error) {
-    // logger.error("Mongo DB memory server connection error");
-    // console.error(error);
-    throw error;
-  }
-};
-
-export const mongoTeardown = async (): Promise<void> => {
-  if (dbConnection) {
-    await dbConnection?.db?.dropDatabase();
-    await dbConnection.close();
-  }
-
-  if (mongoDBMemoryServer) {
-    await mongoDBMemoryServer.stop();
-  }
-};

package/test/unit/lib/global-setup.ts

@@ -1,79 +0,0 @@
-import "reflect-metadata";
-
-import {
-  mongoTeardown,
-  startMongoServerAndSetEnvConnectionString,
-} from "../helpers/database/mongo";
-import { logger } from "../helpers/common/logger";
-
-/**
- * @remarks
- * https://vitest.dev/config/#globalsetup
- */
-
-const formatMemoryUsage = (bytes: number): string =>
-  `${(bytes / 1024 / 1024).toFixed(2)} MB`;
-
-export const setup = async (): Promise<void> => {
-  logger.log({
-    level: "info",
-    action: "setup",
-    msg: "starting",
-  });
-
-  const start = performance.now();
-  const { heapTotal, heapUsed } = process.memoryUsage();
-
-  logger.log({
-    level: "info",
-    action: "setup",
-    msg: `heapTotal memory usage before: ${formatMemoryUsage(heapTotal)}`,
-  });
-  logger.log({
-    level: "info",
-    action: "setup",
-    msg: `heapUsed memory usage before: ${formatMemoryUsage(heapUsed)}`,
-  });
-
-  await startMongoServerAndSetEnvConnectionString();
-
-  const end = performance.now();
-
-  logger.log({
-    level: "info",
-    action: "setup",
-    msg: `completed in ${(end - start).toFixed(2)} ms - ⏱️`,
-  });
-};
-
-export const teardown = async (): Promise<void> => {
-  logger.log({
-    level: "info",
-    action: "teardown",
-    msg: "starting",
-  });
-
-  const start = performance.now();
-  const { heapTotal, heapUsed } = process.memoryUsage();
-
-  logger.log({
-    level: "info",
-    action: "teardown",
-    msg: `heapTotal memory usage after: ${formatMemoryUsage(heapTotal)}`,
-  });
-
-  logger.log({
-    level: "info",
-    action: "teardown",
-    msg: `heapUsed memory usage after: ${formatMemoryUsage(heapUsed)}`,
-  });
-
-  await mongoTeardown();
-
-  const end = performance.now();
-  logger.log({
-    level: "info",
-    action: "teardown",
-    msg: `completed in ${(end - start).toFixed(2)} ms - ⏱️`,
-  });
-};

package/test/unit/lib/setup-files.ts

@@ -1,16 +0,0 @@
-import "reflect-metadata";
-
-import { afterEach, beforeEach, vi } from "vitest";
-
-// /**
-//  * @remarks
-//  * https://vitest.dev/config/#setupfiles
-//  */
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});

package/test/unit/micro-service/architecture/application/application.test.ts

@@ -1,60 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { FastifyRequest } from "fastify";
-
-import {
-  AbstractRouteHandler,
-  Application,
-  ConfigApplication,
-  HookHandler,
-  HookHandlerName,
-  Request,
-} from "../../../../../src/micro-service/architecture/application";
-
-class DummyHookHandler implements HookHandler {
-  public name: HookHandlerName = "onRequest";
-
-  async execute(_: FastifyRequest): Promise<void> {}
-}
-
-import { FastifyReply } from "fastify";
-
-class DummyRouteHandler extends AbstractRouteHandler {
-  constructor() {
-    super({
-      url: "/",
-      schema: {},
-      method: "GET",
-    });
-  }
-
-  handler(_: Request, __: FastifyReply): void | Promise<void> {
-    // Dummy implementation
-    return;
-  }
-}
-
-const fakeConfig: ConfigApplication = {
-  entryPoints: {
-    rest: {
-      hookHandlers: [DummyHookHandler],
-      routeHandlers: [DummyRouteHandler],
-    },
-  },
-};
-
-describe("Application", () => {
-  it("should register hook and route handlers on start", () => {
-    const app = new Application(fakeConfig);
-
-    expect(app.hookHandlers).toHaveLength(0);
-    expect(app.routeHandlers).toHaveLength(0);
-
-    app.start();
-
-    expect(app.hookHandlers).toHaveLength(1);
-    expect(app.routeHandlers).toHaveLength(1);
-
-    expect(app.hookHandlers[0]).toBeInstanceOf(DummyHookHandler);
-    expect(app.routeHandlers[0]).toBeInstanceOf(DummyRouteHandler);
-  });
-});

package/test/unit/micro-service/architecture/application/entry-points/rest/route-handlers/abstract.test.ts

@@ -1,62 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import i18n from "i18n";
-
-import {
-  createFakeFastifyReply,
-  createFakeFastifyRequest,
-} from "../../../../../../helpers/common/common";
-import {
-  AbstractRouteHandler,
-  Request,
-} from "../../../../../../../../src/micro-service/architecture/application";
-
-class TestRouteHandler extends AbstractRouteHandler<
-  void, // Body
-  Record<string, string>, // Querystring
-  void, // Params
-  void // Response
-> {
-  constructor() {
-    super({
-      url: "/",
-      schema: {},
-      method: "GET",
-    });
-  }
-
-  handler(
-    _: Request<
-      void, // Body
-      Record<string, string>, // Querystring
-      void // Params
-    >
-  ): void | Promise<void> {
-    // Dummy implementation
-    return;
-  }
-}
-
-describe("AbstractRouteHandler", () => {
-  it("executes the handler and sends the proper response", async () => {
-    vi.spyOn(i18n, "__").mockReturnValue("Default success");
-
-    const fakeRequest = createFakeFastifyRequest() as Request<
-      void, // Body
-      Record<string, string>, // Querystring
-      void // Params
-    >;
-
-    const fakeReply: any = createFakeFastifyReply();
-
-    const testHandler = new TestRouteHandler();
-
-    await testHandler.execute(fakeRequest, fakeReply);
-
-    expect(fakeReply.code).toHaveBeenCalledWith(200);
-    expect(fakeReply.send).toHaveBeenCalledWith({
-      ok: true,
-      message: "Default success",
-      data: undefined,
-    });
-  });
-});

package/test/unit/micro-service/architecture/application/entry-points/rest/route-handlers/get-route-handler.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import i18n from "i18n";
-
-import { GetRouteHandler } from "../../../../../../../../src/micro-service/architecture/application";
-import {
-  createFakeFastifyReply,
-  createFakeFastifyRequest,
-} from "../../../../../../helpers/common/common";
-import { Request } from "../../../../../../../../src/micro-service/architecture/application";
-
-class TestGetRouteHandler extends GetRouteHandler<unknown, string, unknown> {
-  async handler(_: unknown, __: unknown): Promise<string> {
-    return "Test GET response";
-  }
-}
-
-describe("GetRouteHandler", () => {
-  it("executes GET handler and sends proper response", async () => {
-    vi.spyOn(i18n, "__").mockReturnValue("Default success GET");
-
-    const testHandler = new TestGetRouteHandler({
-      url: "/get-test",
-      schema: {}, // Use an empty schema for test purposes.
-    });
-
-    const fakeRequest = createFakeFastifyRequest() as Request<unknown, string>;
-    const fakeReply = createFakeFastifyReply();
-
-    await testHandler.execute(fakeRequest, fakeReply);
-
-    expect(fakeReply.code).toHaveBeenCalledWith(200);
-    expect(fakeReply.send).toHaveBeenCalledWith({
-      ok: true,
-      message: "Default success GET",
-      data: "Test GET response",
-    });
-  });
-});

package/test/unit/micro-service/architecture/application/entry-points/rest/route-handlers/post-route-handler.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import i18n from "i18n";
-
-import {
-  PostRouteHandler,
-  Request,
-} from "../../../../../../../../src/micro-service/architecture/application";
-import {
-  createFakeFastifyReply,
-  createFakeFastifyRequest,
-} from "../../../../../../helpers/common/common";
-
-class TestPostRouteHandler extends PostRouteHandler<{}, {}, {}, {}> {
-  constructor() {
-    super({
-      url: "/post-test",
-      schema: {}, // Use an empty schema for test purposes.
-    });
-  }
-
-  handler(_: Request<{}, {}, {}>): {} | Promise<{}> {
-    // Dummy implementation
-    return {};
-  }
-}
-
-describe("PostRouteHandler", () => {
-  it("executes POST handler and sends proper response", async () => {
-    vi.spyOn(i18n, "__").mockReturnValue("Default success POST");
-
-    const testHandler = new TestPostRouteHandler();
-
-    const fakeRequest = createFakeFastifyRequest() as Request<{}, {}, {}>;
-    const fakeReply = createFakeFastifyReply();
-
-    await testHandler.execute(fakeRequest, fakeReply);
-
-    expect(fakeReply.code).toHaveBeenCalledWith(200);
-    expect(fakeReply.send).toHaveBeenCalledWith({
-      ok: true,
-      message: "Default success POST",
-      data: {},
-    });
-  });
-});

package/test/unit/micro-service/architecture/architecture.test.ts

@@ -1,64 +0,0 @@
-import { container } from "tsyringe";
-
-import { AbstractArchitecture } from "../../../../src/micro-service/architecture";
-
-class TestArchitecture extends AbstractArchitecture {
-  public start(): void {}
-
-  public testRegisterDependencies<T>(dependencies: Array<new () => T>): void {
-    this.registerDependencies(dependencies);
-  }
-
-  public testRegisterAndStoreDependencies<T>(
-    dependencies: Array<new () => T>,
-    storage: Array<T>
-  ): void {
-    this.registerAndStoreDependencies(dependencies, storage);
-  }
-}
-
-class DummyDependency {
-  public value = "dummy";
-}
-
-describe("AbstractArchitecture", () => {
-  const testArch: TestArchitecture = new TestArchitecture();
-
-  describe("registerDependencies", () => {
-    it("should register each dependency with the container", () => {
-      const spyFunction = vi.spyOn(container, "register");
-
-      testArch.testRegisterDependencies([DummyDependency]);
-
-      expect(spyFunction).toHaveBeenCalledTimes(1);
-      expect(spyFunction).toHaveBeenCalledWith(DummyDependency.name, {
-        useClass: DummyDependency,
-      });
-    });
-  });
-
-  describe("registerAndStoreDependencies", () => {
-    it("should register each dependency and store the resolved instance", () => {
-      const storage: DummyDependency[] = [];
-
-      const spyResolveFunction = vi.spyOn(container, "resolve");
-      const spyRegisterFunction = vi.spyOn(container, "register");
-
-      const dummyInstance = new DummyDependency();
-
-      spyResolveFunction.mockReturnValue(dummyInstance);
-
-      testArch.testRegisterAndStoreDependencies([DummyDependency], storage);
-
-      expect(spyRegisterFunction).toHaveBeenCalledTimes(1);
-      expect(spyRegisterFunction).toHaveBeenCalledWith(DummyDependency.name, {
-        useClass: DummyDependency,
-      });
-
-      expect(spyResolveFunction).toHaveBeenCalledTimes(1);
-      expect(spyResolveFunction).toHaveBeenCalledWith(DummyDependency.name);
-      expect(storage).toHaveLength(1);
-      expect(storage[0]).toBe(dummyInstance);
-    });
-  });
-});

package/test/unit/micro-service/architecture/domain/domain.test.ts

@@ -1,35 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { container } from "tsyringe";
-
-import {
-  Domain,
-  ConfigDomain,
-} from "../../../../../src/micro-service/architecture/domain";
-
-class DummyProvider {
-  public value = "dummy";
-}
-
-class AnotherDummyProvider {
-  public name = "AnotherDummy";
-}
-
-describe("Domain", () => {
-  it("should register the provided domain providers in the DI container", () => {
-    const config: ConfigDomain = {
-      providers: [DummyProvider, AnotherDummyProvider],
-    };
-
-    const domain = new Domain(config);
-
-    domain.start();
-
-    const resolvedDummy = container.resolve(DummyProvider);
-    const resolvedAnother = container.resolve(AnotherDummyProvider);
-
-    expect(resolvedDummy).toBeInstanceOf(DummyProvider);
-    expect(resolvedAnother).toBeInstanceOf(AnotherDummyProvider);
-    expect(resolvedDummy.value).toBe("dummy");
-    expect(resolvedAnother.name).toBe("AnotherDummy");
-  });
-});

package/test/unit/micro-service/architecture/infrastructure/infrastructure.test.ts

@@ -1,33 +0,0 @@
-import {
-  ConfigInfrastructure,
-  Infrastructure,
-} from "../../../../../src/micro-service/architecture/infrastructure";
-
-class DummyRepository {}
-
-const config: ConfigInfrastructure = {
-  repositories: [DummyRepository],
-};
-
-describe("Infrastructure", () => {
-  let infrastructure: Infrastructure;
-
-  beforeEach(() => {
-    infrastructure = new Infrastructure(config);
-  });
-
-  it("should store the configuration passed in the constructor", () => {
-    expect(infrastructure["config"]).toEqual(config);
-  });
-
-  it("should call registerDependencies with provided repositories when start() is called", () => {
-    const registerSpy = vi.spyOn(
-      Object.getPrototypeOf(infrastructure),
-      "registerDependencies"
-    );
-
-    infrastructure.start();
-
-    expect(registerSpy).toHaveBeenCalledWith(config.repositories);
-  });
-});

package/test/unit/micro-service/architecture/infrastructure/repositories/abstract.test.ts

@@ -1,80 +0,0 @@
-import { Schema } from "mongoose";
-import { singleton } from "tsyringe";
-
-import { BaseRepository } from "../../../../../../src/micro-service/architecture/infrastructure";
-import { connectToMongoServerAndRegisterDependency } from "../../../../helpers/database/mongo";
-
-interface UserTest {
-  name: string;
-}
-
-const schemaUserTest = new Schema<UserTest>({
-  name: { type: String, required: true },
-});
-
-@singleton()
-class UserRepository extends BaseRepository<UserTest, UserTest> {
-  constructor() {
-    super({ type: "mongoose", name: "User", schema: schemaUserTest });
-  }
-}
-
-describe("BaseRepository", () => {
-  let repository: UserRepository;
-
-  beforeAll(async () => {
-    await connectToMongoServerAndRegisterDependency();
-
-    repository = new UserRepository();
-  });
-
-  it("should create a model using the provided name and schema", async () => {
-    expect((repository.model as any).modelName).toBe("User");
-    expect((repository.model as any).schema).toBe(schemaUserTest);
-  });
-
-  it("should call create() and return the created user document", async () => {
-    const user = { name: "Alice" };
-
-    const spyFunction = vi.spyOn(repository.model as any, "create");
-
-    const result = await repository.create(user);
-
-    expect(spyFunction).toHaveBeenNthCalledWith(1, user);
-    expect(result).toEqual(expect.objectContaining(user));
-  });
-
-  it("should call findById() and return the user document", async () => {
-    const user = await repository.create({ name: "Alice" });
-    const spyFunction = vi.spyOn(repository.model as any, "findById");
-    const result = await repository.findById(user.id);
-    expect(spyFunction).toHaveBeenNthCalledWith(1, user.id);
-    expect(result).toMatchObject({ name: user.name });
-    expect(result?.id).toBe(user.id);
-  });
-
-  it("should call update() and return the updated user document", async () => {
-    const user = await repository.create({ name: "Alice" });
-
-    const update = { name: "Alice Updated" };
-
-    const spyFunction = vi.spyOn(repository.model as any, "findByIdAndUpdate");
-
-    const result = await repository.update(user.id, update);
-
-    expect(spyFunction).toHaveBeenNthCalledWith(1, user.id, update, {
-      new: true,
-    });
-    expect(result).toEqual(expect.objectContaining(update));
-  });
-
-  it("should call delete() and return the deleted user document", async () => {
-    const user = await repository.create({ name: "Alice" });
-    const spyFunction = vi.spyOn(repository.model as any, "findByIdAndDelete");
-    const result = await repository.delete(user.id);
-    expect(spyFunction).toHaveBeenNthCalledWith(1, user.id);
-    // Patch: allow for id only (ignore _id)
-    expect(result).toMatchObject({ name: user.name });
-    expect(result?.id).toBe(user.id);
-  });
-});

package/test/unit/micro-service/architecture/platform/micro-service.test.ts

@@ -1,86 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-
-import {
-  ConfigMicroService,
-  MicroService,
-} from "../../../../../src/micro-service/architecture/platform/micro-service";
-import { Application } from "../../../../../src/micro-service/architecture/application";
-import { Infrastructure } from "../../../../../src/micro-service/architecture/infrastructure";
-import {
-  Service,
-  HandlersType,
-} from "../../../../../src/micro-service/architecture/platform/service/service";
-import { Domain } from "../../../../../src/micro-service/architecture/domain";
-
-describe("MicroService", () => {
-  let config: ConfigMicroService;
-  let microService: MicroService;
-
-  const port = 3000;
-
-  // We’ll use a minimal config—since MicroService just passes these objects to the constructors,
-  // we can use empty objects or simple stubs as necessary.
-  beforeEach(() => {
-    config = {
-      architecture: {
-        application: {} as any,
-        domain: {} as any,
-        infrastructure: {} as any,
-        service: {} as any,
-      },
-    };
-
-    // Create a MicroService instance using the config.
-    microService = new MicroService(config);
-
-    // For our test we want the application instance to have defined route and hook handlers.
-    // Since MicroService calls:
-    //   service.registerHandlers({ handlers: this.application.routeHandlers, ... })
-    // we assign dummy values.
-    (microService as any).application.routeHandlers = ["dummyRouteHandler"];
-    (microService as any).application.hookHandlers = ["dummyHookHandler"];
-  });
-
-  it("should start the micro service by starting application, domain, infrastructure and service", async () => {
-    // Arrange: create spies on the start and register methods of the dependencies.
-    // Spying on the prototype methods works because the MicroService instance calls these methods.
-    const appStartSpy = vi
-      .spyOn(Application.prototype, "start")
-      .mockImplementation(() => {});
-    const domainStartSpy = vi
-      .spyOn(Domain.prototype, "start")
-      .mockImplementation(() => {});
-    const infrastructureStartSpy = vi
-      .spyOn(Infrastructure.prototype, "start")
-      .mockImplementation(() => {});
-    const serviceRegisterHandlersSpy = vi
-      .spyOn(Service.prototype, "registerHandlers")
-      .mockImplementation(() => Promise.resolve());
-    const serviceStartSpy = vi
-      .spyOn(Service.prototype, "start")
-      .mockImplementation(() => Promise.resolve());
-
-    // Act: Call MicroService.start().
-    await microService.start({ port });
-
-    // Assert: Verify that the underlying dependencies were started as expected.
-    expect(appStartSpy).toHaveBeenCalled();
-    expect(domainStartSpy).toHaveBeenCalled();
-    expect(infrastructureStartSpy).toHaveBeenCalled();
-
-    // Assert registerHandlers was called twice:
-    // First for route handlers...
-    expect(serviceRegisterHandlersSpy).toHaveBeenNthCalledWith(1, {
-      handlers: (microService as any).application.routeHandlers,
-      handlersType: HandlersType.ROUTE,
-    });
-    // ...and second for hook handlers.
-    expect(serviceRegisterHandlersSpy).toHaveBeenNthCalledWith(2, {
-      handlers: (microService as any).application.hookHandlers,
-      handlersType: HandlersType.HOOK,
-    });
-
-    // Assert that service.start was called with the expected port.
-    expect(serviceStartSpy).toHaveBeenCalledWith({ port });
-  });
-});