wsp-ms-core 1.0.1 → 1.0.3

package/src/infrastructure/contracts/DatabaseConnection.ts

@@ -1,11 +0,0 @@
-
-export interface DatabaseConnection<Q = string, Params = unknown[], Row = Record<string, unknown>> {
-
-    query<T = Row>(statement: Q, params?: Params): Promise<T[]>;
-    begin(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(toSavepoint?: string): Promise<void>;
-    transaction<T>(fn: (conn: this) => Promise<T>): Promise<T>;
-    close(): Promise<void>;
-
-}

package/src/infrastructure/contracts/DatabaseConnector.ts

@@ -1,8 +0,0 @@
-import {DatabaseConnection} from "@infrastructure/contracts/DatabaseConnection";
-
-export interface DatabaseConnector<C extends DatabaseConnection = DatabaseConnection> {
-
-    getConnection(options?: { readonly?: boolean }): Promise<C>;
-    closePool(): Promise<void>;
-
-}

package/src/infrastructure/contracts/Logger.ts

@@ -1,9 +0,0 @@
-export interface Logger {
-
-    debug(type: string, message: string, meta?: Record<string, any>): void;
-    info(type: string, message: string, meta?: Record<string, any>): void;
-    warn(type: string, message: string, meta?: Record<string, any>): void;
-    error(type: string, message: string, meta?: Record<string, any>): void;
-    fatal(type: string, message: string, meta?: Record<string, any>): void;
-
-}

package/src/infrastructure/errors/ErrorManager.ts

@@ -1,93 +0,0 @@
-import {Language} from "@domain/value-objects/Language";
-import {FatalError} from "@domain/errors/FatalError";
-import {InternalError} from "@domain/errors/InternalError";
-import {UsageError} from "@domain/errors/UsageError";
-import {StringVars} from "@utils/StringVars";
-import {Logger} from "@infrastructure/contracts/Logger";
-
-export interface ErrorTemplate {
-    type: string;
-    languages: Record<string, string>;
-}
-
-export type ErrorManagerHandleResult = {
-    status: number | string;
-    message: string;
-};
-
-export class ErrorManager {
-
-    private static readonly DEFAULT_MESSAGES: Record<string, string> = {
-        'es': 'Ups, hemos encontrado un error. Nuestro equipo ya está trabajando para solucionarlo',
-        'en': 'Ups, we found an error. Our team is working on it.',
-        'pt': 'Ops, encontramos um bug. Nossa equipe já está trabalhando para resolver isso.',
-    };
-
-    public static readonly APP_ERRORS = {
-        UNDEFINED: 'UNDEFINED_ERROR',
-        PROCESS: 'PROCESS_ERROR',
-        DATABASE: 'DATABASE_ERROR'
-    } as const;
-
-    private static readonly TEMPLATES = new Map<string, ErrorTemplate>();
-
-    public constructor(private readonly logger: Logger | null = null) {}
-
-    private getDefaultMessage(lang: Language): string {
-        return (ErrorManager.DEFAULT_MESSAGES[lang.value] || ErrorManager.DEFAULT_MESSAGES[lang.base()] || 'error');
-    }
-
-    private onFatal(err: FatalError, lang: Language): ErrorManagerHandleResult {
-        this.logger?.fatal(err.type, err.message);
-        return { status: 'ERROR', message: this.getDefaultMessage(lang) };
-    }
-
-    private onInternal(err: InternalError, lang: Language): ErrorManagerHandleResult {
-        this.logger?.error(err.type, err.message);
-        return { status: 'ERROR', message: this.getDefaultMessage(lang) };
-    }
-
-    private onUsage(err: UsageError, lang: Language): ErrorManagerHandleResult {
-        const tmpl = ErrorManager.TEMPLATES.get(err.type);
-        if (!tmpl) {
-            this.logger?.error('TEMPLATE_NOT_FOUND', `${err.type}`);
-            return { status: 'ERROR', message: this.getDefaultMessage(lang) };
-        }
-        const code = lang.value;
-        const base = lang.base();
-        const rawMsg =
-            tmpl.languages[code] ??
-            tmpl.languages[base] ??
-            this.getDefaultMessage(lang);
-        return {
-            status: 'ERROR',
-            message: StringVars.parse(rawMsg, err.vars),
-        };
-    }
-
-    private onUnknown(err: Error, lang: Language): ErrorManagerHandleResult {
-        this.logger?.error('UNKNOWN_ERROR', err.message);
-        return { status: 'ERROR', message: this.getDefaultMessage(lang) };
-    }
-
-    public handle(err: Error, lang: Language): ErrorManagerHandleResult {
-        if (['local','dev'].includes(process.env.ENVIRONMENT ?? '')) {
-            console.log(err);
-        }
-        if (err instanceof FatalError) {
-            return this.onFatal(err, lang);
-        }
-        if (err instanceof InternalError) {
-            return this.onInternal(err, lang);
-        }
-        if (err instanceof UsageError) {
-            return this.onUsage(err, lang);
-        }
-        return this.onUnknown(err, lang);
-    }
-
-    public static addTemplate(template: ErrorTemplate): void {
-        ErrorManager.TEMPLATES.set(template.type, template);
-    }
-
-}

package/src/infrastructure/mysql/MysqlConnection.ts

@@ -1,45 +0,0 @@
-import {FieldPacket, PoolConnection, RowDataPacket} from "mysql2/promise";
-import {DatabaseConnection} from "@infrastructure/contracts/DatabaseConnection";
-
-export class MysqlConnection implements DatabaseConnection<string, any[], RowDataPacket> {
-
-    private readonly _conn: PoolConnection;
-
-    public constructor(conn: PoolConnection) {
-        this._conn = conn;
-    }
-
-    public async query<R = RowDataPacket>(statement: string, params: any[] = [],): Promise<R[]> {
-        const [rows] = await this._conn.query<R[] & RowDataPacket[] & FieldPacket[]>(statement, params);
-        return rows as R[];
-    }
-
-    public async begin(): Promise<void> {
-        await this._conn.beginTransaction();
-    }
-
-    public async commit(): Promise<void> {
-        await this._conn.commit();
-    }
-
-    public async rollback(): Promise<void> {
-        await this._conn.rollback();
-    }
-
-    public async transaction<T>(fn: (conn: this) => Promise<T>): Promise<T> {
-        await this.begin();
-        try {
-            const result: T = await fn(this);
-            await this.commit();
-            return result;
-        } catch (err) {
-            await this.rollback();
-            throw err;
-        }
-    }
-
-    public async close(): Promise<void> {
-        this._conn.release();
-    }
-
-}

package/src/infrastructure/mysql/MysqlConnector.ts

@@ -1,51 +0,0 @@
-import { createPool, Pool, PoolConnection } from 'mysql2/promise';
-import {DatabaseConnector} from "@infrastructure/contracts/DatabaseConnector";
-import {MysqlConnection} from "@infrastructure/mysql/MysqlConnection";
-
-export class MysqlConnector implements DatabaseConnector<MysqlConnection> {
-    public static readonly DEFAULT_POOL_SIZE: number = 10;
-
-    private readonly _pool: Pool;
-
-    public constructor(pool?: Pool) {
-        this._pool =
-            pool ??
-            createPool({
-                host:     process.env.DB_HOST,
-                port:     Number(process.env.DB_PORT ?? 3306),
-                user:     process.env.DB_USER,
-                password: process.env.DB_PASSWORD,
-                database: process.env.DB_NAME,
-                connectionLimit:
-                    Number(process.env.DB_POOL_SIZE) || MysqlConnector.DEFAULT_POOL_SIZE,
-                decimalNumbers: true,
-            });
-    }
-
-    private async wrap(conn: PoolConnection): Promise<MysqlConnection> {
-        return new MysqlConnection(conn);
-    }
-
-    public async getConnection(): Promise<MysqlConnection> {
-        const conn: PoolConnection = await this._pool.getConnection();
-        return this.wrap(conn);
-    }
-
-    public async closePool(): Promise<void> {
-        await this._pool.end();
-    }
-
-    public static async ping(): Promise<boolean> {
-        const connector: MysqlConnector = new MysqlConnector();
-        try {
-            const conn = await connector._pool.getConnection();
-            await conn.ping();
-            conn.release();
-            return true;
-        } catch {
-            return false;
-        } finally {
-            await connector.closePool();
-        }
-    }
-}

package/src/utils/StringVars.ts

@@ -1,14 +0,0 @@
-export class StringVars {
-
-    public static parse(str: string, ob: { [key: string]: any }): string {
-        const regex = /{{(.*?)}}/g;
-        return str.replace(regex, (match, variable) => {
-            if (ob.hasOwnProperty(variable.trim())) {
-                return ob[variable.trim()];
-            } else {
-                return match;
-            }
-        });
-    }
-
-}

package/test/domain/value-objects/Currency.test.ts

@@ -1,48 +0,0 @@
-import { Currency } from '@domain/value-objects/Currency';
-
-describe('Currency ValueObject', () => {
-
-    it('creates from alpha code (case‑insensitive) and exposes numeric', () => {
-        const uyu = Currency.create('uyu');
-        expect(uyu.value).toBe('UYU');
-        expect(uyu.numeric).toBe(858);
-    });
-
-    it('creates from numeric code (number) and maps to alpha', () => {
-        const uyu = Currency.create(858);
-        expect(uyu.value).toBe('UYU');
-        expect(uyu.numeric).toBe(858);
-    });
-
-    it('creates from numeric code (string) and maps to alpha', () => {
-        const ars = Currency.create('032');
-        expect(ars.value).toBe('ARS');
-        expect(ars.numeric).toBe(32);
-    });
-
-    it('equals() returns true for different representations of same currency', () => {
-        const a = Currency.create('uyu');
-        const b = Currency.create(858);
-        expect(a.equals(b)).toBe(true);
-        expect(a.equals(Currency.UYU)).toBe(true);
-    });
-
-    it('isValid() returns true for valid inputs', () => {
-        expect(Currency.isValid('USD')).toBe(true);
-        expect(Currency.isValid(840)).toBe(true);
-    });
-
-    it('isValid() returns false for invalid inputs', () => {
-        expect(Currency.isValid('US')).toBe(false);
-        expect(Currency.isValid('USDX')).toBe(false);
-        expect(Currency.isValid(999)).toBe(false);
-    });
-
-    it('throws when alpha code is invalid', () => {
-        expect(() => Currency.create('ABC1')).toThrow(Error);
-    });
-
-    it('throws when numeric code is unknown', () => {
-        expect(() => Currency.create(999)).toThrow(Error);
-    });
-});

package/test/domain/value-objects/DateTime.test.ts

@@ -1,32 +0,0 @@
-import { DateTime } from '@domain/value-objects/DateTime';
-
-describe('DateTime ValueObject', () => {
-    const ISO = '2025-07-27T15:30:00Z';
-    const TS  = Date.parse(ISO);
-
-    it('creates from ISO string', () => {
-        const dt = DateTime.create(ISO);
-        expect(dt.value).toBe('2025-07-27 15:30:00');
-        expect(dt.year).toBe(2025);
-    });
-
-    it('creates from timestamp', () => {
-        const dt = DateTime.create(TS);
-        expect(dt.day).toBe(27);
-    });
-
-    it('plusDays() returns a new DateTime with expected day', () => {
-        const dt = DateTime.create(ISO).plusDays(3);
-        expect(dt.day).toBe(30);
-    });
-
-    it('minusHours() returns a new DateTime with expected hour', () => {
-        const dt = DateTime.create(ISO).minusHours(2);
-        expect(dt.hour).toBe(13);
-    });
-
-    it('getMonthName() obeys locale', () => {
-        const dt = DateTime.create(ISO);
-        expect(dt.getMonthName('es')).toBe('julio'); // Luxon locale
-    });
-});

package/test/domain/value-objects/Email.test.ts

@@ -1,38 +0,0 @@
-import { Email } from '@domain/value-objects/Email';
-
-describe('Email ValueObject', () => {
-
-    it('creates from a valid e‑mail string', () => {
-        const mail = Email.create('user@example.com');
-        expect(mail.value).toBe('user@example.com');
-    });
-
-    it('trims whitespace before validation/storage', () => {
-        const mail = Email.create('  user@example.com \n');
-        expect(mail.value).toBe('user@example.com');
-    });
-
-    it('equals() returns true for the exact same address string', () => {
-        const a = Email.create('user@example.com');
-        const b = Email.create('user@example.com');
-        expect(a.equals(b)).toBe(true);
-    });
-
-    it('equals() is case‑sensitive (default behaviour)', () => {
-        const a = Email.create('User@Example.com');
-        const b = Email.create('user@example.com');
-        expect(a.equals(b)).toBe(false);
-    });
-
-    it('isValid() returns true for a correct address', () => {
-        expect(Email.isValid('user@example.com')).toBe(true);
-    });
-
-    it('isValid() returns false for an incorrect address', () => {
-        expect(Email.isValid('not‑an‑email')).toBe(false);
-    });
-
-    it('throws when the address is invalid', () => {
-        expect(() => Email.create('bad‑mail')).toThrow(Error);
-    });
-});

package/test/domain/value-objects/Language.test.ts

@@ -1,76 +0,0 @@
-import { Language } from '@domain/value-objects/Language';
-
-describe('Language ValueObject', () => {
-    describe('create()', () => {
-        it('creates from lowercase code and preserves value', () => {
-            const lang = Language.create('es');
-            expect(lang.value).toBe('es');
-        });
-
-        it('creates from uppercase code by normalizing to lowercase', () => {
-            const lang = Language.create('ES-AR');
-            expect(lang.value).toBe('es-ar');
-        });
-
-        it('replaces underscore with hyphen and normalizes', () => {
-            const lang = Language.create('EN_US');
-            expect(lang.value).toBe('en-us');
-        });
-
-        it('trims whitespace around the code', () => {
-            const lang = Language.create('  en-gb  ');
-            expect(lang.value).toBe('en-gb');
-        });
-    });
-
-    describe('supported constants', () => {
-        it('has a DEFAULT constant of "es"', () => {
-            expect(Language.DEFAULT.value).toBe('es');
-        });
-
-        it('has an ENGLISH_UNITED_STATES constant of "en-us"', () => {
-            expect(Language.ENGLISH_UNITED_STATES.value).toBe('en-us');
-        });
-    });
-
-    describe('base()', () => {
-        it('returns "es" for Spanish variants', () => {
-            const lang = Language.create('es-mx');
-            expect(lang.base()).toBe('es');
-        });
-
-        it('returns "en" for English variants', () => {
-            const lang = Language.create('en-za');
-            expect(lang.base()).toBe('en');
-        });
-
-        it('returns the same value if no region part', () => {
-            const lang = Language.create('pt');
-            expect(lang.base()).toBe('pt');
-        });
-    });
-
-    describe('equals()', () => {
-        it('returns true for two identical codes', () => {
-            const a = Language.create('es');
-            const b = Language.create('ES');
-            expect(a.equals(b)).toBe(true);
-        });
-
-        it('returns false for different codes', () => {
-            const a = Language.create('en');
-            const b = Language.create('es');
-            expect(a.equals(b)).toBe(false);
-        });
-    });
-
-    describe('validation errors', () => {
-        it('throws when creating an unsupported code', () => {
-            expect(() => Language.create('fr')).toThrow('Language <fr> is not supported');
-        });
-
-        it('throws when creating an empty string', () => {
-            expect(() => Language.create('')).toThrow('Language <> is not supported');
-        });
-    });
-});

package/test/domain/value-objects/Price.test.ts

@@ -1,96 +0,0 @@
-import { Price } from '@domain/value-objects/Price';
-import { Currency } from '@domain/value-objects/Currency';
-
-describe('Price ValueObject', () => {
-    describe('create()', () => {
-        it('creates with numeric amount and string currency code', () => {
-            const p = Price.create(100, 'USD');
-            expect(p.amount).toBe(100);
-            expect(p.currency.value).toBe('USD');
-            expect(p.currency.numeric).toBe(840);
-        });
-
-        it('creates with negative amount ≥ MIN_AMOUNT', () => {
-            const min = Price.MIN_AMOUNT;
-            const p = Price.create(min, Currency.create('EUR'));
-            expect(p.amount).toBe(min);
-            expect(p.currency.equals(Currency.EUR)).toBe(true);
-        });
-    });
-
-    describe('equals()', () => {
-        it('returns true for same amount and currency', () => {
-            const a = Price.create(50, 'BRL');
-            const b = Price.create(50, '986'); // numeric code
-            expect(a.equals(b)).toBe(true);
-        });
-
-        it('returns false if other is null or undefined', () => {
-            const a = Price.create(50, 'BRL');
-            expect(a.equals(null)).toBe(false);
-            expect(a.equals(undefined)).toBe(false);
-        });
-
-        it('returns false for different amount or currency', () => {
-            const a = Price.create(50, 'BRL');
-            const b = Price.create(60, 'BRL');
-            const c = Price.create(50, 'USD');
-            expect(a.equals(b)).toBe(false);
-            expect(a.equals(c)).toBe(false);
-        });
-    });
-
-    describe('add()', () => {
-        it('adds two prices with the same currency', () => {
-            const a = Price.create(100, 'UYU');
-            const b = Price.create(200, 858);
-            const sum = a.add(b);
-            expect(sum.amount).toBe(300);
-            expect(sum.currency.equals(a.currency)).toBe(true);
-        });
-
-        it('throws if currencies differ', () => {
-            const a = Price.create(100, 'USD');
-            const b = Price.create(100, 'EUR');
-            expect(() => a.add(b)).toThrow('Cannot operate on Price objects with different currencies');
-        });
-    });
-
-    describe('subtract()', () => {
-        it('subtracts two prices with the same currency', () => {
-            const a = Price.create(300, 'USD');
-            const b = Price.create(100, 'USD');
-            const diff = a.subtract(b);
-            expect(diff.amount).toBe(200);
-            expect(diff.currency.value).toBe('USD');
-        });
-
-        it('throws if currencies differ', () => {
-            const a = Price.create(100, 'USD');
-            const b = Price.create(50, 'UYU');
-            expect(() => a.subtract(b)).toThrow('Cannot operate on Price objects with different currencies');
-        });
-    });
-
-    describe('validation', () => {
-        it('throws for non-number amount', () => {
-            // @ts-ignore
-            expect(() => Price.create('foo', 'USD')).toThrow('Price amount <foo> is not a valid number');
-        });
-
-        it('throws for NaN amount', () => {
-            expect(() => Price.create(NaN, 'USD')).toThrow('Price amount <NaN> is not a valid number');
-        });
-
-        it('throws for infinite amount', () => {
-            expect(() => Price.create(Infinity, 'USD')).toThrow('Price amount <Infinity> is not a valid number');
-        });
-
-        it('throws for amount below MIN_AMOUNT', () => {
-            const below = Price.MIN_AMOUNT - 1;
-            expect(() => Price.create(below, 'USD')).toThrow(
-                `Price amount <${below}> must be ≥ ${Price.MIN_AMOUNT}`
-            );
-        });
-    });
-});

package/test/domain/value-objects/UUID.test.ts

@@ -1,18 +0,0 @@
-import { UUID } from '@domain/value-objects/UUID';
-
-describe('UUID ValueObject', () => {
-    it('creates a valid v4 UUID via static create()', () => {
-        const id = UUID.create();
-        expect(UUID.isValid(id.value)).toBe(true);
-    });
-
-    it('throws when uuid string is invalid', () => {
-        expect(() => UUID.create('not-a-uuid')).toThrow();
-    });
-
-    it('equals() compares by value', () => {
-        const a = UUID.create('11111111-1111-4111-8111-111111111111');
-        const b = UUID.create('11111111-1111-4111-8111-111111111111');
-        expect(a.equals(b)).toBe(true);
-    });
-});

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

@@ -1,125 +0,0 @@
-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.',
-            });
-        });
-    });
-
-});