@eratu/common 1.0.17 → 1.0.19

package/build/__tests__/enum/roles.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/enum/roles.test.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const roles_1 = require("../../enum/roles");
+describe('UserRoles Enum', () => {
+    it('should have superAdmin with value 1', () => {
+        expect(roles_1.UserRoles.superAdmin).toBe(1);
+    });
+    it('should have admin with value 2', () => {
+        expect(roles_1.UserRoles.admin).toBe(2);
+    });
+    it('should have author with value 3', () => {
+        expect(roles_1.UserRoles.author).toBe(3);
+    });
+    it('should have reader with value 4', () => {
+        expect(roles_1.UserRoles.reader).toBe(4);
+    });
+    it('should have exactly 4 roles', () => {
+        const roles = Object.keys(roles_1.UserRoles).filter((key) => isNaN(Number(key)));
+        expect(roles.length).toBe(4);
+        expect(roles).toContain('superAdmin');
+        expect(roles).toContain('admin');
+        expect(roles).toContain('author');
+        expect(roles).toContain('reader');
+    });
+    it('should support reverse mapping', () => {
+        expect(roles_1.UserRoles[1]).toBe('superAdmin');
+        expect(roles_1.UserRoles[2]).toBe('admin');
+        expect(roles_1.UserRoles[3]).toBe('author');
+        expect(roles_1.UserRoles[4]).toBe('reader');
+    });
+});

package/build/__tests__/errors/bad-request-error.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/errors/bad-request-error.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bad_request_error_1 = require("../../errors/bad-request-error");
+const custom_error_1 = require("../../errors/custom-error");
+describe('BadRequestError', () => {
+    it('should extend CustomError', () => {
+        const error = new bad_request_error_1.BadRequestError('Test error');
+        expect(error).toBeInstanceOf(custom_error_1.CustomError);
+        expect(error).toBeInstanceOf(Error);
+    });
+    it('should have statusCode of 400', () => {
+        const error = new bad_request_error_1.BadRequestError('Test error');
+        expect(error.statusCode).toBe(400);
+    });
+    it('should store the message', () => {
+        const message = 'Invalid email format';
+        const error = new bad_request_error_1.BadRequestError(message);
+        expect(error.message).toBe(message);
+    });
+    it('should serialize errors correctly', () => {
+        const message = 'Invalid input';
+        const error = new bad_request_error_1.BadRequestError(message);
+        const serialized = error.serializeErrors();
+        expect(serialized).toEqual([{ message }]);
+    });
+    it('should have correct prototype chain', () => {
+        const error = new bad_request_error_1.BadRequestError('Test');
+        expect(Object.getPrototypeOf(error)).toBe(bad_request_error_1.BadRequestError.prototype);
+    });
+});

package/build/__tests__/errors/database-connection-error.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/errors/database-connection-error.test.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const database_connection_error_1 = require("../../errors/database-connection-error");
+const custom_error_1 = require("../../errors/custom-error");
+describe('DatabaseConnectionError', () => {
+    it('should extend CustomError', () => {
+        const error = new database_connection_error_1.DatabaseConnectionError();
+        expect(error).toBeInstanceOf(custom_error_1.CustomError);
+        expect(error).toBeInstanceOf(Error);
+    });
+    it('should have statusCode of 500', () => {
+        const error = new database_connection_error_1.DatabaseConnectionError();
+        expect(error.statusCode).toBe(500);
+    });
+    it('should have reason property', () => {
+        const error = new database_connection_error_1.DatabaseConnectionError();
+        expect(error.reason).toBe('Error connecting to database');
+    });
+    it('should serialize errors correctly', () => {
+        const error = new database_connection_error_1.DatabaseConnectionError();
+        const serialized = error.serializeErrors();
+        expect(serialized).toEqual([{ message: 'Error connecting to database' }]);
+    });
+    it('should have correct prototype chain', () => {
+        const error = new database_connection_error_1.DatabaseConnectionError();
+        expect(Object.getPrototypeOf(error)).toBe(database_connection_error_1.DatabaseConnectionError.prototype);
+    });
+});

package/build/__tests__/errors/forbidden-error.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/errors/forbidden-error.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const forbidden_error_1 = require("../../errors/forbidden-error");
+const custom_error_1 = require("../../errors/custom-error");
+describe('ForbiddenError', () => {
+    it('should extend CustomError', () => {
+        const error = new forbidden_error_1.ForbiddenError();
+        expect(error).toBeInstanceOf(custom_error_1.CustomError);
+        expect(error).toBeInstanceOf(Error);
+    });
+    it('should have statusCode of 403', () => {
+        const error = new forbidden_error_1.ForbiddenError();
+        expect(error.statusCode).toBe(403);
+    });
+    it('should have default message "Forbidden"', () => {
+        const error = new forbidden_error_1.ForbiddenError();
+        expect(error.message).toBe('Forbidden');
+    });
+    it('should accept custom message', () => {
+        const customMessage = 'Access denied for this resource';
+        const error = new forbidden_error_1.ForbiddenError(customMessage);
+        expect(error.message).toBe(customMessage);
+    });
+    it('should serialize errors correctly with default message', () => {
+        const error = new forbidden_error_1.ForbiddenError();
+        const serialized = error.serializeErrors();
+        expect(serialized).toEqual([{ message: 'Forbidden' }]);
+    });
+    it('should serialize errors correctly with custom message', () => {
+        const customMessage = 'Insufficient permissions';
+        const error = new forbidden_error_1.ForbiddenError(customMessage);
+        const serialized = error.serializeErrors();
+        expect(serialized).toEqual([{ message: customMessage }]);
+    });
+    it('should have correct prototype chain', () => {
+        const error = new forbidden_error_1.ForbiddenError();
+        expect(Object.getPrototypeOf(error)).toBe(forbidden_error_1.ForbiddenError.prototype);
+    });
+});

package/build/__tests__/errors/not-authorized-error.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/errors/not-authorized-error.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const not_authorized_error_1 = require("../../errors/not-authorized-error");
+const custom_error_1 = require("../../errors/custom-error");
+describe('NotAuthorizedError', () => {
+    it('should extend CustomError', () => {
+        const error = new not_authorized_error_1.NotAuthorizedError();
+        expect(error).toBeInstanceOf(custom_error_1.CustomError);
+        expect(error).toBeInstanceOf(Error);
+    });
+    it('should have statusCode of 401', () => {
+        const error = new not_authorized_error_1.NotAuthorizedError();
+        expect(error.statusCode).toBe(401);
+    });
+    it('should have default message "Not Authorized"', () => {
+        const error = new not_authorized_error_1.NotAuthorizedError();
+        expect(error.message).toBe('Not Authorized');
+    });
+    it('should accept custom message', () => {
+        const customMessage = 'Session expired';
+        const error = new not_authorized_error_1.NotAuthorizedError(customMessage);
+        expect(error.message).toBe(customMessage);
+    });
+    it('should serialize errors correctly with default message', () => {
+        const error = new not_authorized_error_1.NotAuthorizedError();
+        const serialized = error.serializeErrors();
+        expect(serialized).toEqual([{ message: 'Not Authorized' }]);
+    });
+    it('should serialize errors correctly with custom message', () => {
+        const customMessage = 'Token expired';
+        const error = new not_authorized_error_1.NotAuthorizedError(customMessage);
+        const serialized = error.serializeErrors();
+        expect(serialized).toEqual([{ message: customMessage }]);
+    });
+    it('should have correct prototype chain', () => {
+        const error = new not_authorized_error_1.NotAuthorizedError();
+        expect(Object.getPrototypeOf(error)).toBe(not_authorized_error_1.NotAuthorizedError.prototype);
+    });
+});

package/build/__tests__/errors/not-found-error.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/errors/not-found-error.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const not_found_error_1 = require("../../errors/not-found-error");
+const custom_error_1 = require("../../errors/custom-error");
+describe('NotFoundError', () => {
+    it('should extend CustomError', () => {
+        const error = new not_found_error_1.NotFoundError();
+        expect(error).toBeInstanceOf(custom_error_1.CustomError);
+        expect(error).toBeInstanceOf(Error);
+    });
+    it('should have statusCode of 404', () => {
+        const error = new not_found_error_1.NotFoundError();
+        expect(error.statusCode).toBe(404);
+    });
+    it('should have default message "Not Found"', () => {
+        const error = new not_found_error_1.NotFoundError();
+        expect(error.message).toBe('Not Found');
+    });
+    it('should accept custom message', () => {
+        const customMessage = 'User not found';
+        const error = new not_found_error_1.NotFoundError(customMessage);
+        expect(error.message).toBe(customMessage);
+    });
+    it('should serialize errors correctly with default message', () => {
+        const error = new not_found_error_1.NotFoundError();
+        const serialized = error.serializeErrors();
+        expect(serialized).toEqual([{ message: 'Not Found' }]);
+    });
+    it('should serialize errors correctly with custom message', () => {
+        const customMessage = 'Book not found';
+        const error = new not_found_error_1.NotFoundError(customMessage);
+        const serialized = error.serializeErrors();
+        expect(serialized).toEqual([{ message: customMessage }]);
+    });
+    it('should have correct prototype chain', () => {
+        const error = new not_found_error_1.NotFoundError();
+        expect(Object.getPrototypeOf(error)).toBe(not_found_error_1.NotFoundError.prototype);
+    });
+});

package/build/__tests__/errors/request-validation-error.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/errors/request-validation-error.test.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const request_validation_error_1 = require("../../errors/request-validation-error");
+const custom_error_1 = require("../../errors/custom-error");
+describe('RequestValidationError', () => {
+    it('should extend CustomError', () => {
+        const error = new request_validation_error_1.RequestValidationError([]);
+        expect(error).toBeInstanceOf(custom_error_1.CustomError);
+        expect(error).toBeInstanceOf(Error);
+    });
+    it('should have statusCode of 400', () => {
+        const error = new request_validation_error_1.RequestValidationError([]);
+        expect(error.statusCode).toBe(400);
+    });
+    it('should have message "Invalid request parameters"', () => {
+        const error = new request_validation_error_1.RequestValidationError([]);
+        expect(error.message).toBe('Invalid request parameters');
+    });
+    it('should serialize field errors correctly', () => {
+        const validationErrors = [
+            {
+                type: 'field',
+                msg: 'Email is required',
+                path: 'email',
+                location: 'body',
+                value: '',
+            },
+            {
+                type: 'field',
+                msg: 'Password must be at least 8 characters',
+                path: 'password',
+                location: 'body',
+                value: '123',
+            },
+        ];
+        const error = new request_validation_error_1.RequestValidationError(validationErrors);
+        const serialized = error.serializeErrors();
+        expect(serialized).toEqual([
+            { message: 'Email is required', field: 'email' },
+            { message: 'Password must be at least 8 characters', field: 'password' },
+        ]);
+    });
+    it('should serialize non-field errors correctly', () => {
+        const validationErrors = [
+            {
+                type: 'alternative',
+                msg: 'At least one field is required',
+                nestedErrors: [],
+            },
+        ];
+        const error = new request_validation_error_1.RequestValidationError(validationErrors);
+        const serialized = error.serializeErrors();
+        expect(serialized).toEqual([
+            { message: 'At least one field is required' },
+        ]);
+    });
+    it('should serialize mixed errors correctly', () => {
+        const validationErrors = [
+            {
+                type: 'field',
+                msg: 'Invalid email',
+                path: 'email',
+                location: 'body',
+                value: 'invalid',
+            },
+            {
+                type: 'alternative_grouped',
+                msg: 'Alternative error',
+                nestedErrors: [],
+            },
+        ];
+        const error = new request_validation_error_1.RequestValidationError(validationErrors);
+        const serialized = error.serializeErrors();
+        expect(serialized).toEqual([
+            { message: 'Invalid email', field: 'email' },
+            { message: 'Alternative error' },
+        ]);
+    });
+    it('should handle empty errors array', () => {
+        const error = new request_validation_error_1.RequestValidationError([]);
+        const serialized = error.serializeErrors();
+        expect(serialized).toEqual([]);
+    });
+    it('should have correct prototype chain', () => {
+        const error = new request_validation_error_1.RequestValidationError([]);
+        expect(Object.getPrototypeOf(error)).toBe(request_validation_error_1.RequestValidationError.prototype);
+    });
+    it('should store errors array', () => {
+        const validationErrors = [
+            {
+                type: 'field',
+                msg: 'Test error',
+                path: 'test',
+                location: 'body',
+                value: '',
+            },
+        ];
+        const error = new request_validation_error_1.RequestValidationError(validationErrors);
+        expect(error.errors).toEqual(validationErrors);
+    });
+});

package/build/__tests__/events/base-listener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/events/base-listener.test.js

@@ -0,0 +1,222 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_listener_1 = require("../../events/listeners/base-listener");
+const subjects_1 = require("../../events/subjects");
+const streams_1 = require("../../events/streams");
+const nats_1 = require("nats");
+class TestListener extends base_listener_1.Listener {
+    constructor() {
+        super(...arguments);
+        this.subject = subjects_1.Subjects.AuthorSignedUp;
+        this.stream = streams_1.Streams.AuthServiceStream;
+        this.durableName = 'test-durable';
+        this.onMessage = jest.fn();
+    }
+}
+describe('Listener', () => {
+    let mockJs;
+    let mockJsm;
+    let listener;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockJsm = {
+            streams: {
+                info: jest.fn().mockResolvedValue({}),
+            },
+            consumers: {
+                info: jest.fn().mockResolvedValue({}),
+                add: jest.fn().mockResolvedValue({}),
+            },
+        };
+        mockJs = {
+            consumers: {
+                get: jest.fn(),
+            },
+        };
+        listener = new TestListener(mockJs, mockJsm);
+    });
+    describe('constructor', () => {
+        it('should initialize with JetStreamClient and JetStreamManager', () => {
+            expect(listener).toBeDefined();
+        });
+    });
+    describe('waitForStream', () => {
+        it('should succeed when stream exists', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockConsumer = {
+                consume: jest.fn().mockResolvedValue({
+                    [Symbol.asyncIterator]: () => ({
+                        next: jest.fn().mockResolvedValue({ done: true }),
+                    }),
+                }),
+            };
+            mockJs.consumers.get.mockResolvedValue(mockConsumer);
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            // We need to start listen and then stop it to test waitForStream
+            const listenPromise = listener.listen();
+            // Let it resolve
+            yield Promise.resolve();
+            yield Promise.resolve();
+            expect(mockJsm.streams.info).toHaveBeenCalledWith(streams_1.Streams.AuthServiceStream);
+            expect(consoleSpy).toHaveBeenCalledWith(`✅ Stream "${streams_1.Streams.AuthServiceStream}" is ready`);
+            consoleSpy.mockRestore();
+        }));
+        it('should retry when stream does not exist initially', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.useFakeTimers();
+            mockJsm.streams.info = jest.fn()
+                .mockRejectedValueOnce(new Error('Stream not found'))
+                .mockResolvedValueOnce({});
+            const mockConsumer = {
+                consume: jest.fn().mockResolvedValue({
+                    [Symbol.asyncIterator]: () => ({
+                        next: jest.fn().mockResolvedValue({ done: true }),
+                    }),
+                }),
+            };
+            mockJs.consumers.get.mockResolvedValue(mockConsumer);
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            const listenPromise = listener.listen();
+            // First attempt fails, advance time for retry
+            yield jest.advanceTimersByTimeAsync(2000);
+            yield Promise.resolve();
+            expect(consoleSpy).toHaveBeenCalledWith(`⏳ Waiting for stream "${streams_1.Streams.AuthServiceStream}"...`);
+            expect(mockJsm.streams.info).toHaveBeenCalledTimes(2);
+            consoleSpy.mockRestore();
+            jest.useRealTimers();
+        }));
+        it('should throw error after max retry attempts', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.useFakeTimers();
+            mockJsm.streams.info = jest.fn().mockRejectedValue(new Error('Stream not found'));
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+            const listenPromise = listener.listen().catch(e => e);
+            // Advance through all retries (6 attempts, 2s each)
+            for (let i = 0; i < 6; i++) {
+                yield jest.advanceTimersByTimeAsync(2000);
+                yield Promise.resolve();
+            }
+            const error = yield listenPromise;
+            expect(error).toBeInstanceOf(Error);
+            expect(error.message).toBe(`Stream "${streams_1.Streams.AuthServiceStream}" is not ready`);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(`❌ Stream "${streams_1.Streams.AuthServiceStream}" is not ready after 5 attempts`);
+            consoleSpy.mockRestore();
+            consoleErrorSpy.mockRestore();
+            jest.useRealTimers();
+        }));
+    });
+    describe('createConsumerIfNotExists', () => {
+        it('should not create consumer if it already exists', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockConsumer = {
+                consume: jest.fn().mockResolvedValue({
+                    [Symbol.asyncIterator]: () => ({
+                        next: jest.fn().mockResolvedValue({ done: true }),
+                    }),
+                }),
+            };
+            mockJs.consumers.get.mockResolvedValue(mockConsumer);
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            yield listener.listen();
+            expect(mockJsm.consumers.info).toHaveBeenCalledWith(streams_1.Streams.AuthServiceStream, 'test-durable');
+            expect(mockJsm.consumers.add).not.toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        }));
+        it('should create consumer if it does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockJsm.consumers.info = jest.fn().mockRejectedValueOnce(new Error('Consumer not found'));
+            const mockConsumer = {
+                consume: jest.fn().mockResolvedValue({
+                    [Symbol.asyncIterator]: () => ({
+                        next: jest.fn().mockResolvedValue({ done: true }),
+                    }),
+                }),
+            };
+            mockJs.consumers.get.mockResolvedValue(mockConsumer);
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            yield listener.listen();
+            expect(mockJsm.consumers.add).toHaveBeenCalledWith(streams_1.Streams.AuthServiceStream, {
+                durable_name: 'test-durable',
+                ack_policy: 'explicit',
+                ack_wait: 5 * 1000 * 1000000,
+                filter_subject: subjects_1.Subjects.AuthorSignedUp,
+            });
+            consoleSpy.mockRestore();
+        }));
+    });
+    describe('listen', () => {
+        it('should process messages through onMessage', () => __awaiter(void 0, void 0, void 0, function* () {
+            const testData = { id: 'test-id', email: 'test@test.com' };
+            const codec = (0, nats_1.JSONCodec)();
+            const encodedData = codec.encode(testData);
+            const mockMsg = {
+                data: encodedData,
+                ack: jest.fn(),
+            };
+            let messageCount = 0;
+            const mockConsumer = {
+                consume: jest.fn().mockResolvedValue({
+                    [Symbol.asyncIterator]: () => ({
+                        next: jest.fn().mockImplementation(() => {
+                            messageCount++;
+                            if (messageCount === 1) {
+                                return Promise.resolve({ value: mockMsg, done: false });
+                            }
+                            return Promise.resolve({ done: true });
+                        }),
+                    }),
+                }),
+            };
+            mockJs.consumers.get.mockResolvedValue(mockConsumer);
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            yield listener.listen();
+            expect(listener.onMessage).toHaveBeenCalledWith(testData, mockMsg);
+            consoleSpy.mockRestore();
+        }));
+    });
+    describe('parseMessage', () => {
+        it('should correctly decode JSON messages', () => __awaiter(void 0, void 0, void 0, function* () {
+            const testData = { id: 'parse-test', email: 'parse@test.com' };
+            const codec = (0, nats_1.JSONCodec)();
+            const encodedData = codec.encode(testData);
+            const mockMsg = {
+                data: encodedData,
+            };
+            let messageCount = 0;
+            const mockConsumer = {
+                consume: jest.fn().mockResolvedValue({
+                    [Symbol.asyncIterator]: () => ({
+                        next: jest.fn().mockImplementation(() => {
+                            messageCount++;
+                            if (messageCount === 1) {
+                                return Promise.resolve({ value: mockMsg, done: false });
+                            }
+                            return Promise.resolve({ done: true });
+                        }),
+                    }),
+                }),
+            };
+            mockJs.consumers.get.mockResolvedValue(mockConsumer);
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            yield listener.listen();
+            expect(listener.onMessage).toHaveBeenCalledWith(testData, expect.anything());
+            consoleSpy.mockRestore();
+        }));
+    });
+    describe('subject, stream, and durableName', () => {
+        it('should have correct subject', () => {
+            expect(listener.subject).toBe(subjects_1.Subjects.AuthorSignedUp);
+        });
+        it('should have correct stream', () => {
+            expect(listener.stream).toBe(streams_1.Streams.AuthServiceStream);
+        });
+        it('should have correct durableName', () => {
+            expect(listener.durableName).toBe('test-durable');
+        });
+    });
+});

package/build/__tests__/events/base-publisher.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/events/base-publisher.test.js

@@ -0,0 +1,85 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_publisher_1 = require("../../events/publishers/base-publisher");
+const subjects_1 = require("../../events/subjects");
+const streams_1 = require("../../events/streams");
+const nats_1 = require("nats");
+class TestPublisher extends base_publisher_1.Publisher {
+    constructor() {
+        super(...arguments);
+        this.subject = subjects_1.Subjects.AuthorSignedUp;
+        this.stream = streams_1.Streams.AuthServiceStream;
+    }
+}
+describe('Publisher', () => {
+    let mockJsClient;
+    let publisher;
+    beforeEach(() => {
+        mockJsClient = {
+            publish: jest.fn().mockResolvedValue({}),
+        };
+        publisher = new TestPublisher(mockJsClient);
+    });
+    describe('constructor', () => {
+        it('should initialize with JetStreamClient', () => {
+            expect(publisher).toBeDefined();
+        });
+    });
+    describe('publish', () => {
+        it('should encode and publish message to the correct subject', () => __awaiter(void 0, void 0, void 0, function* () {
+            const testData = { id: 'test-id', email: 'test@test.com' };
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            yield publisher.publish(testData);
+            expect(mockJsClient.publish).toHaveBeenCalledTimes(1);
+            expect(mockJsClient.publish).toHaveBeenCalledWith(subjects_1.Subjects.AuthorSignedUp, expect.any(Uint8Array));
+            expect(consoleSpy).toHaveBeenCalledWith(`Message published to ${subjects_1.Subjects.AuthorSignedUp}:`, testData);
+            consoleSpy.mockRestore();
+        }));
+        it('should properly encode the data using JSONCodec', () => __awaiter(void 0, void 0, void 0, function* () {
+            const testData = { id: 'test-id', email: 'test@test.com' };
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            yield publisher.publish(testData);
+            // Verify the published message can be decoded back to original data
+            const publishCall = mockJsClient.publish.mock.calls[0];
+            const encodedData = publishCall[1];
+            const codec = (0, nats_1.JSONCodec)();
+            const decodedData = codec.decode(encodedData);
+            expect(decodedData).toEqual(testData);
+            consoleSpy.mockRestore();
+        }));
+        it('should handle complex data objects', () => __awaiter(void 0, void 0, void 0, function* () {
+            const complexData = {
+                id: 'complex-id',
+                email: 'complex@test.com',
+            };
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            yield publisher.publish(complexData);
+            expect(mockJsClient.publish).toHaveBeenCalledTimes(1);
+            consoleSpy.mockRestore();
+        }));
+        it('should propagate errors from JetStreamClient', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockJsClient.publish.mockRejectedValueOnce(new Error('Publish failed'));
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            const testData = { id: 'test-id', email: 'test@test.com' };
+            yield expect(publisher.publish(testData)).rejects.toThrow('Publish failed');
+            consoleSpy.mockRestore();
+        }));
+    });
+    describe('subject and stream', () => {
+        it('should have correct subject', () => {
+            expect(publisher.subject).toBe(subjects_1.Subjects.AuthorSignedUp);
+        });
+        it('should have correct stream', () => {
+            expect(publisher.stream).toBe(streams_1.Streams.AuthServiceStream);
+        });
+    });
+});

package/build/__tests__/events/streams.test.d.ts

@@ -0,0 +1 @@
+export {};