wsp-ms-core 1.0.0

package/test/infrastructure/errors/ErrorManager.test.ts

@@ -0,0 +1,125 @@
+import { ErrorManager, ErrorTemplate } from '@infrastructure/errors/ErrorManager';
+import { Language } from '@domain/value-objects/Language';
+import {Logger} from "@infrastructure/contracts/Logger";
+import {FatalError} from "@domain/errors/FatalError";
+import {InternalError} from "@domain/errors/InternalError";
+import {UsageError} from "@domain/errors/UsageError";
+
+describe('ErrorManager', () => {
+    let logger: Logger;
+    let manager: ErrorManager;
+
+    beforeEach(() => {
+        // Reset environment and templates
+        delete process.env.ENVIRONMENT;
+        manager = new ErrorManager(logger = {
+            debug: jest.fn(),
+            info: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+            fatal: jest.fn(),
+        });
+        // Clear private TEMPLATES map
+        (ErrorManager as any).TEMPLATES.clear();
+    });
+
+    describe('handle FatalError', () => {
+        it('logs fatal and returns default message for exact language', () => {
+            const err = new FatalError('TEST_FATAL', 'fatal happened');
+            const lang = Language.create('es');
+            const res = manager.handle(err, lang);
+            expect(logger.fatal).toHaveBeenCalledWith('TEST_FATAL', 'fatal happened');
+            expect(res).toEqual({
+                status: 'ERROR',
+                message: 'Ups, hemos encontrado un error. Nuestro equipo ya está trabajando para solucionarlo',
+            });
+        });
+
+        it('falls back to base language if specific not defined', () => {
+            const err = new FatalError('TF', 'msg');
+            const lang = Language.create('es-uy');
+            const res = manager.handle(err, lang);
+            // 'es-uy' not in DEFAULT_MESSAGES, fallback to 'es'
+            expect(res.message).toContain('Ups, hemos encontrado un error');
+        });
+    });
+
+    describe('handle InternalError', () => {
+        it('logs error and returns default message', () => {
+            const err = new InternalError('DB_ERR', 'db failure');
+            const lang = Language.create('en-gb');
+            const res = manager.handle(err, lang);
+            expect(logger.error).toHaveBeenCalledWith('DB_ERR', 'db failure');
+            expect(res).toEqual({
+                status: 'ERROR',
+                message: 'Ups, we found an error. Our team is working on it.',
+            });
+        });
+    });
+
+    describe('handle UsageError without template', () => {
+        it('logs template-not-found and returns default fallback', () => {
+            const err = new UsageError('MISSING', { foo: 'bar' });
+            const lang = Language.create('pt-br');
+            const res = manager.handle(err, lang);
+            expect(logger.error).toHaveBeenCalledWith('TEMPLATE_NOT_FOUND', 'MISSING');
+            expect(res).toEqual({
+                status: 'ERROR',
+                message: 'Ops, encontramos um bug. Nossa equipe já está trabalhando para resolver isso.',
+            });
+        });
+    });
+
+    describe('handle UsageError with template', () => {
+        it('renders template for exact locale', () => {
+            const tmpl: ErrorTemplate = {
+                type: 'GREETING',
+                languages: {
+                    'es': 'Hola {{name}}',
+                    'en': 'Hello {{name}}',
+                },
+            };
+            ErrorManager.addTemplate(tmpl);
+
+            const err = new UsageError('GREETING', { name: 'Luis' });
+            const lang = Language.create('es');
+            const res = manager.handle(err, lang);
+            expect(res).toEqual({
+                status: 'ERROR',
+                message: 'Hola Luis',
+            });
+        });
+
+        it('falls back to base locale if exact not present', () => {
+            const tmpl: ErrorTemplate = {
+                type: 'BYE',
+                languages: {
+                    'en': 'Bye {{who}}',
+                },
+            };
+            ErrorManager.addTemplate(tmpl);
+
+            const err = new UsageError('BYE', { who: 'World' });
+            const lang = Language.create('en-au');
+            const res = manager.handle(err, lang);
+            expect(res).toEqual({
+                status: 'ERROR',
+                message: 'Bye World',
+            });
+        });
+    });
+
+    describe('handle unknown Error', () => {
+        it('logs unknown and returns default message', () => {
+            const err = new Error('something bad');
+            const lang = Language.create('en');
+            const res = manager.handle(err, lang);
+            expect(logger.error).toHaveBeenCalledWith('UNKNOWN_ERROR', 'something bad');
+            expect(res).toEqual({
+                status: 'ERROR',
+                message: 'Ups, we found an error. Our team is working on it.',
+            });
+        });
+    });
+
+});

package/test/infrastructure/mysql/MysqlConnection.test.ts

@@ -0,0 +1,45 @@
+import { MysqlConnection } from '@infrastructure/mysql/MysqlConnection';
+import { PoolConnection } from 'mysql2/promise';
+
+describe('MysqlConnection transaction()', () => {
+    it('wraps begin → commit on success', async () => {
+        const mockConn = {
+            beginTransaction:  jest.fn(),
+            commit:            jest.fn(),
+            rollback:          jest.fn(),
+            query:             jest.fn().mockResolvedValue([[]]),
+            release:           jest.fn(),
+        } as unknown as PoolConnection;
+
+        const db = new MysqlConnection(mockConn);
+
+        await db.transaction(async (c) => {
+            await c.query('SELECT 1');
+        });
+
+        expect(mockConn.beginTransaction).toHaveBeenCalled();
+        expect(mockConn.commit).toHaveBeenCalled();
+        expect(mockConn.rollback).not.toHaveBeenCalled();
+    });
+
+    it('wraps begin → rollback on error', async () => {
+        const mockConn = {
+            beginTransaction:  jest.fn(),
+            commit:            jest.fn(),
+            rollback:          jest.fn(),
+            query:             jest.fn().mockResolvedValue([[]]),
+            release:           jest.fn(),
+        } as unknown as PoolConnection;
+
+        const db = new MysqlConnection(mockConn);
+
+        await expect(
+            db.transaction(async () => {
+                throw new Error('fail');
+            }),
+        ).rejects.toThrow('fail');
+
+        expect(mockConn.rollback).toHaveBeenCalled();
+        expect(mockConn.commit).not.toHaveBeenCalled();
+    });
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "types": ["node", "jest"],
+    "baseUrl": "src",
+    "paths": {
+      "@domain/*":        ["domain/*"],
+      "@application/*":   ["application/*"],
+      "@infrastructure/*":["infrastructure/*"],
+      "@utils/*":         ["utils/*"]
+    },
+  }
+}

package/tsup.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from 'tsup';
+import alias from 'esbuild-plugin-alias';
+import path from 'path';
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    format: ['esm', 'cjs'],
+    dts: true,
+    sourcemap: true,
+    esbuildPlugins: [
+        alias({
+            '@domain':        path.resolve(__dirname, 'src/domain'),
+            '@application':   path.resolve(__dirname, 'src/application'),
+            '@infrastructure':path.resolve(__dirname, 'src/infrastructure'),
+            '@utils':         path.resolve(__dirname, 'src/utils'),
+        }),
+    ],
+});