@eratu/common 1.0.21 → 1.0.22

package/build/__tests__/middlewares/validation.test.js

@@ -1,198 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-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 class_validator_1 = require("class-validator");
-const validation_1 = require("../../middlewares/validation");
-// Test DTOs
-class TestUserDto {
-}
-__decorate([
-    (0, class_validator_1.IsEmail)(),
-    __metadata("design:type", String)
-], TestUserDto.prototype, "email", void 0);
-__decorate([
-    (0, class_validator_1.IsString)(),
-    (0, class_validator_1.MinLength)(8),
-    __metadata("design:type", String)
-], TestUserDto.prototype, "password", void 0);
-__decorate([
-    (0, class_validator_1.IsOptional)(),
-    (0, class_validator_1.IsString)(),
-    __metadata("design:type", String)
-], TestUserDto.prototype, "firstName", void 0);
-class TestQueryDto {
-}
-__decorate([
-    (0, class_validator_1.IsOptional)(),
-    (0, class_validator_1.IsInt)(),
-    (0, class_validator_1.Min)(1),
-    __metadata("design:type", Number)
-], TestQueryDto.prototype, "page", void 0);
-describe('validationMiddleware', () => {
-    let mockReq;
-    let mockRes;
-    let mockNext;
-    beforeEach(() => {
-        mockReq = {
-            body: {},
-            query: {},
-            params: {},
-        };
-        mockRes = {
-            status: jest.fn().mockReturnThis(),
-            json: jest.fn(),
-        };
-        mockNext = jest.fn();
-    });
-    describe('body validation', () => {
-        it('should call next() when body is valid', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockReq.body = {
-                email: 'test@example.com',
-                password: 'password123',
-            };
-            const middleware = (0, validation_1.validationMiddleware)(TestUserDto);
-            yield middleware(mockReq, mockRes, mockNext);
-            expect(mockNext).toHaveBeenCalledTimes(1);
-            expect(mockRes.status).not.toHaveBeenCalled();
-        }));
-        it('should return 400 when email is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockReq.body = {
-                email: 'invalid-email',
-                password: 'password123',
-            };
-            const middleware = (0, validation_1.validationMiddleware)(TestUserDto);
-            yield middleware(mockReq, mockRes, mockNext);
-            expect(mockNext).not.toHaveBeenCalled();
-            expect(mockRes.status).toHaveBeenCalledWith(400);
-            expect(mockRes.json).toHaveBeenCalledWith(expect.objectContaining({
-                status: 400,
-                message: 'Validation failed',
-                errors: expect.arrayContaining([
-                    expect.objectContaining({
-                        field: 'email',
-                    }),
-                ]),
-            }));
-        }));
-        it('should return 400 when password is too short', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockReq.body = {
-                email: 'test@example.com',
-                password: 'short',
-            };
-            const middleware = (0, validation_1.validationMiddleware)(TestUserDto);
-            yield middleware(mockReq, mockRes, mockNext);
-            expect(mockNext).not.toHaveBeenCalled();
-            expect(mockRes.status).toHaveBeenCalledWith(400);
-            expect(mockRes.json).toHaveBeenCalledWith(expect.objectContaining({
-                errors: expect.arrayContaining([
-                    expect.objectContaining({
-                        field: 'password',
-                    }),
-                ]),
-            }));
-        }));
-        it('should return 400 when required fields are missing', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockReq.body = {};
-            const middleware = (0, validation_1.validationMiddleware)(TestUserDto);
-            yield middleware(mockReq, mockRes, mockNext);
-            expect(mockNext).not.toHaveBeenCalled();
-            expect(mockRes.status).toHaveBeenCalledWith(400);
-            expect(mockRes.json).toHaveBeenCalledWith(expect.objectContaining({
-                errors: expect.arrayContaining([
-                    expect.objectContaining({ field: 'email' }),
-                    expect.objectContaining({ field: 'password' }),
-                ]),
-            }));
-        }));
-        it('should handle optional fields correctly', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockReq.body = {
-                email: 'test@example.com',
-                password: 'password123',
-                firstName: 'John',
-            };
-            const middleware = (0, validation_1.validationMiddleware)(TestUserDto);
-            yield middleware(mockReq, mockRes, mockNext);
-            expect(mockNext).toHaveBeenCalledTimes(1);
-            expect(mockReq.body.firstName).toBe('John');
-        }));
-        it('should return 400 when non-whitelisted properties are present', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockReq.body = {
-                email: 'test@example.com',
-                password: 'password123',
-                hackerField: 'malicious',
-            };
-            const middleware = (0, validation_1.validationMiddleware)(TestUserDto);
-            yield middleware(mockReq, mockRes, mockNext);
-            expect(mockNext).not.toHaveBeenCalled();
-            expect(mockRes.status).toHaveBeenCalledWith(400);
-        }));
-        it('should skip missing properties when skipMissingProperties is true', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockReq.body = {
-                email: 'test@example.com',
-                // password is missing
-            };
-            const middleware = (0, validation_1.validationMiddleware)(TestUserDto, 'body', true);
-            yield middleware(mockReq, mockRes, mockNext);
-            expect(mockNext).toHaveBeenCalledTimes(1);
-        }));
-    });
-    describe('query validation', () => {
-        it('should validate query parameters', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockReq.query = {
-                page: 1,
-            };
-            const middleware = (0, validation_1.validationMiddleware)(TestQueryDto, 'query');
-            yield middleware(mockReq, mockRes, mockNext);
-            expect(mockNext).toHaveBeenCalledTimes(1);
-        }));
-    });
-    describe('error handling', () => {
-        it('should return 500 when an internal error occurs', () => __awaiter(void 0, void 0, void 0, function* () {
-            // Force an error by providing invalid input that causes plainToClass to fail
-            // We'll mock plainToClass to throw
-            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-            // Create a scenario that causes internal error
-            mockReq.body = null;
-            // This might not throw, but let's test that errors are handled
-            const middleware = (0, validation_1.validationMiddleware)(TestUserDto);
-            yield middleware(mockReq, mockRes, mockNext);
-            // In this case, it may pass validation since null becomes empty object
-            // The point is to ensure the middleware doesn't crash
-            consoleErrorSpy.mockRestore();
-        }));
-    });
-    describe('body transformation', () => {
-        it('should attach transformed DTO to request body', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockReq.body = {
-                email: 'test@example.com',
-                password: 'password123',
-                firstName: 'John',
-            };
-            const middleware = (0, validation_1.validationMiddleware)(TestUserDto);
-            yield middleware(mockReq, mockRes, mockNext);
-            expect(mockNext).toHaveBeenCalledTimes(1);
-            expect(mockReq.body).toEqual(expect.objectContaining({
-                email: 'test@example.com',
-                password: 'password123',
-                firstName: 'John',
-            }));
-        }));
-    });
-});

package/build/__tests__/nats-wrapper.test.d.ts

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

package/build/__tests__/nats-wrapper.test.js

@@ -1,159 +0,0 @@
-"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 nats_1 = require("nats");
-const nats_wrapper_1 = require("../nats-wrapper");
-const streams_1 = require("../events/streams");
-const subjects_1 = require("../events/subjects");
-// Mock nats module
-jest.mock('nats', () => ({
-    connect: jest.fn(),
-}));
-const mockConnect = nats_1.connect;
-describe('NatsWrapper', () => {
-    let natsWrapper;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        natsWrapper = new nats_wrapper_1.NatsWrapper(streams_1.Streams.AuthServiceStream, [
-            subjects_1.Subjects.AuthorSignedUp,
-            subjects_1.Subjects.ReaderSignedUp,
-        ]);
-    });
-    describe('getters before initialization', () => {
-        it('should throw error when accessing natsConnection before init', () => {
-            expect(() => natsWrapper.natsConnection).toThrow('Cannot access NATS client before initialization');
-        });
-        it('should throw error when accessing jetStreamClient before init', () => {
-            expect(() => natsWrapper.jetStreamClient).toThrow('Cannot access JetStream client before initialization');
-        });
-        it('should throw error when accessing jetStreamManager before init', () => {
-            expect(() => natsWrapper.jetStreamManager).toThrow('Cannot access JetStream manager before initialization');
-        });
-    });
-    describe('connect', () => {
-        it('should connect to NATS successfully', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockJsm = {
-                streams: {
-                    info: jest.fn().mockResolvedValue({}),
-                    add: jest.fn().mockResolvedValue({}),
-                },
-            };
-            const mockJs = jest.fn();
-            const mockConnection = {
-                jetstream: jest.fn().mockReturnValue(mockJs),
-                jetstreamManager: jest.fn().mockResolvedValue(mockJsm),
-            };
-            mockConnect.mockResolvedValueOnce(mockConnection);
-            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-            yield natsWrapper.connect('nats://localhost:4222');
-            expect(mockConnect).toHaveBeenCalledWith({ servers: ['nats://localhost:4222'] });
-            expect(consoleSpy).toHaveBeenCalledWith('✅ Connected to NATS');
-            expect(natsWrapper.natsConnection).toBe(mockConnection);
-            expect(natsWrapper.jetStreamClient).toBe(mockJs);
-            consoleSpy.mockRestore();
-        }));
-        it('should create stream if it does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockJsm = {
-                streams: {
-                    info: jest.fn().mockRejectedValueOnce(new Error('Stream not found')),
-                    add: jest.fn().mockResolvedValue({}),
-                },
-            };
-            const mockJs = jest.fn();
-            const mockConnection = {
-                jetstream: jest.fn().mockReturnValue(mockJs),
-                jetstreamManager: jest.fn().mockResolvedValue(mockJsm),
-            };
-            mockConnect.mockResolvedValueOnce(mockConnection);
-            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-            yield natsWrapper.connect('nats://localhost:4222');
-            expect(mockJsm.streams.add).toHaveBeenCalledWith({
-                name: streams_1.Streams.AuthServiceStream,
-                subjects: [subjects_1.Subjects.AuthorSignedUp, subjects_1.Subjects.ReaderSignedUp],
-            });
-            consoleSpy.mockRestore();
-        }));
-        it('should retry connection on failure', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockJsm = {
-                streams: {
-                    info: jest.fn().mockResolvedValue({}),
-                },
-            };
-            const mockConnection = {
-                jetstream: jest.fn().mockReturnValue({}),
-                jetstreamManager: jest.fn().mockResolvedValue(mockJsm),
-            };
-            mockConnect
-                .mockRejectedValueOnce(new Error('Connection failed'))
-                .mockRejectedValueOnce(new Error('Connection failed'))
-                .mockResolvedValueOnce(mockConnection);
-            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-            // Override setTimeout to speed up test
-            jest.useFakeTimers();
-            const connectPromise = natsWrapper.connect('nats://localhost:4222');
-            // Fast-forward through retries
-            yield jest.advanceTimersByTimeAsync(3000);
-            yield jest.advanceTimersByTimeAsync(3000);
-            yield connectPromise;
-            expect(mockConnect).toHaveBeenCalledTimes(3);
-            expect(consoleErrorSpy).toHaveBeenCalledTimes(2);
-            expect(consoleSpy).toHaveBeenCalledWith('✅ Connected to NATS');
-            consoleSpy.mockRestore();
-            consoleErrorSpy.mockRestore();
-            jest.useRealTimers();
-        }));
-        it('should throw error after max retry attempts', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockConnect.mockRejectedValue(new Error('Connection failed'));
-            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-            jest.useFakeTimers();
-            // Start the connection and immediately attach the rejection handler
-            const connectPromise = natsWrapper.connect('nats://localhost:4222').catch(e => e);
-            // Run all timers and pending promises to completion
-            yield jest.runAllTimersAsync();
-            const error = yield connectPromise;
-            expect(error).toBeInstanceOf(Error);
-            expect(error.message).toBe('NATS connection failed');
-            expect(mockConnect).toHaveBeenCalledTimes(6);
-            expect(consoleErrorSpy).toHaveBeenCalledTimes(6);
-            consoleSpy.mockRestore();
-            consoleErrorSpy.mockRestore();
-            jest.useRealTimers();
-        }));
-    });
-    describe('getters after initialization', () => {
-        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-            const mockJsm = {
-                streams: {
-                    info: jest.fn().mockResolvedValue({}),
-                },
-            };
-            const mockJs = { publish: jest.fn() };
-            const mockConnection = {
-                jetstream: jest.fn().mockReturnValue(mockJs),
-                jetstreamManager: jest.fn().mockResolvedValue(mockJsm),
-            };
-            mockConnect.mockResolvedValueOnce(mockConnection);
-            jest.spyOn(console, 'log').mockImplementation();
-            yield natsWrapper.connect('nats://localhost:4222');
-        }));
-        it('should return natsConnection after init', () => {
-            expect(natsWrapper.natsConnection).toBeDefined();
-        });
-        it('should return jetStreamClient after init', () => {
-            expect(natsWrapper.jetStreamClient).toBeDefined();
-        });
-        it('should return jetStreamManager after init', () => {
-            expect(natsWrapper.jetStreamManager).toBeDefined();
-        });
-    });
-});

package/build/__tests__/redis-wrapper.test.d.ts

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

package/build/__tests__/redis-wrapper.test.js

@@ -1,159 +0,0 @@
-"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 ioredis_1 = require("ioredis");
-const redis_wrapper_1 = require("../redis-wrapper");
-// Mock ioredis
-jest.mock('ioredis', () => {
-    return {
-        Redis: jest.fn().mockImplementation(() => ({
-            connect: jest.fn().mockResolvedValue(undefined),
-            quit: jest.fn().mockResolvedValue(undefined),
-            set: jest.fn().mockResolvedValue('OK'),
-            get: jest.fn().mockResolvedValue('value'),
-        })),
-    };
-});
-const MockRedis = ioredis_1.Redis;
-describe('RedisWrapper', () => {
-    let redisWrapper;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        redisWrapper = new redis_wrapper_1.RedisWrapper();
-    });
-    describe('constructor', () => {
-        it('should use default values when no params provided', () => {
-            const wrapper = new redis_wrapper_1.RedisWrapper();
-            // The wrapper is created, defaults are used internally
-            expect(wrapper).toBeDefined();
-        });
-        it('should accept custom params', () => {
-            const wrapper = new redis_wrapper_1.RedisWrapper({
-                host: 'custom-host',
-                port: 6380,
-                username: 'user',
-                password: 'pass',
-            });
-            expect(wrapper).toBeDefined();
-        });
-    });
-    describe('client getter before connection', () => {
-        it('should throw error when accessing client before connecting', () => {
-            expect(() => redisWrapper.client).toThrow('Cannot access Redis client before connecting');
-        });
-    });
-    describe('connect', () => {
-        it('should connect to Redis successfully', () => __awaiter(void 0, void 0, void 0, function* () {
-            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-            yield redisWrapper.connect();
-            expect(MockRedis).toHaveBeenCalledWith({
-                host: 'localhost',
-                port: 6379,
-                username: '',
-                password: '',
-                lazyConnect: true,
-            });
-            expect(consoleSpy).toHaveBeenCalledWith('✅ Connected to Redis');
-            consoleSpy.mockRestore();
-        }));
-        it('should connect with custom params', () => __awaiter(void 0, void 0, void 0, function* () {
-            const customWrapper = new redis_wrapper_1.RedisWrapper({
-                host: 'redis.example.com',
-                port: 6380,
-                username: 'admin',
-                password: 'secret',
-            });
-            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-            yield customWrapper.connect();
-            expect(MockRedis).toHaveBeenCalledWith({
-                host: 'redis.example.com',
-                port: 6380,
-                username: 'admin',
-                password: 'secret',
-                lazyConnect: true,
-            });
-            consoleSpy.mockRestore();
-        }));
-        it('should handle connection error', () => __awaiter(void 0, void 0, void 0, function* () {
-            MockRedis.mockImplementationOnce(() => ({
-                connect: jest.fn().mockRejectedValue(new Error('Connection failed')),
-            }));
-            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-            const wrapper = new redis_wrapper_1.RedisWrapper();
-            yield wrapper.connect();
-            expect(consoleErrorSpy).toHaveBeenCalledWith('❌ Error connecting to Redis:', 'Connection failed');
-            expect(consoleSpy).toHaveBeenCalledWith('❌ Failed to connect to Redis');
-            consoleSpy.mockRestore();
-            consoleErrorSpy.mockRestore();
-        }));
-    });
-    describe('disconnect', () => {
-        it('should disconnect from Redis successfully', () => __awaiter(void 0, void 0, void 0, function* () {
-            jest.spyOn(console, 'log').mockImplementation();
-            yield redisWrapper.connect();
-            yield redisWrapper.disconnect();
-            // No error thrown means success
-            expect(true).toBe(true);
-        }));
-        it('should handle disconnect error gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
-            MockRedis.mockImplementationOnce(() => ({
-                connect: jest.fn().mockResolvedValue(undefined),
-                quit: jest.fn().mockRejectedValue(new Error('Disconnect failed')),
-            }));
-            const wrapper = new redis_wrapper_1.RedisWrapper();
-            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-            yield wrapper.connect();
-            yield wrapper.disconnect();
-            expect(consoleErrorSpy).toHaveBeenCalledWith('❌ Error disconnecting from Redis:', 'Disconnect failed');
-            consoleSpy.mockRestore();
-            consoleErrorSpy.mockRestore();
-        }));
-        it('should handle disconnect when not connected', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield redisWrapper.disconnect();
-            // Should not throw
-            expect(true).toBe(true);
-        }));
-    });
-    describe('set', () => {
-        it('should throw error when not connected', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield expect(redisWrapper.set('key', 'value', 60)).rejects.toThrow('Redis not connected');
-        }));
-        it('should set value with expiration', () => __awaiter(void 0, void 0, void 0, function* () {
-            jest.spyOn(console, 'log').mockImplementation();
-            yield redisWrapper.connect();
-            yield redisWrapper.set('testKey', 'testValue', 300);
-            const mockClient = MockRedis.mock.results[0].value;
-            expect(mockClient.set).toHaveBeenCalledWith('testKey', 'testValue', 'EX', 300);
-        }));
-    });
-    describe('get', () => {
-        it('should throw error when not connected', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield expect(redisWrapper.get('key')).rejects.toThrow('Redis not connected');
-        }));
-        it('should get value', () => __awaiter(void 0, void 0, void 0, function* () {
-            jest.spyOn(console, 'log').mockImplementation();
-            yield redisWrapper.connect();
-            const result = yield redisWrapper.get('testKey');
-            expect(result).toBe('value');
-            const mockClient = MockRedis.mock.results[0].value;
-            expect(mockClient.get).toHaveBeenCalledWith('testKey');
-        }));
-    });
-    describe('client getter after connection', () => {
-        it('should return client after connecting', () => __awaiter(void 0, void 0, void 0, function* () {
-            jest.spyOn(console, 'log').mockImplementation();
-            yield redisWrapper.connect();
-            expect(redisWrapper.client).toBeDefined();
-        }));
-    });
-});

package/build/enum/image.d.ts

@@ -1,14 +0,0 @@
-export declare enum ImageType {
-    cover = 1,
-    profile = 2,
-    book = 3,
-    banner = 4,
-    genreImage = 5,
-    genreIcon = 6,
-    subgenreImage = 7,
-    subgenreIcon = 8,
-    promoImage = 9,
-    promoIcon = 10,
-    chapter = 11,
-    authorDocument = 12
-}

package/build/enum/image.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImageType = void 0;
-var ImageType;
-(function (ImageType) {
-    ImageType[ImageType["cover"] = 1] = "cover";
-    ImageType[ImageType["profile"] = 2] = "profile";
-    ImageType[ImageType["book"] = 3] = "book";
-    ImageType[ImageType["banner"] = 4] = "banner";
-    ImageType[ImageType["genreImage"] = 5] = "genreImage";
-    ImageType[ImageType["genreIcon"] = 6] = "genreIcon";
-    ImageType[ImageType["subgenreImage"] = 7] = "subgenreImage";
-    ImageType[ImageType["subgenreIcon"] = 8] = "subgenreIcon";
-    ImageType[ImageType["promoImage"] = 9] = "promoImage";
-    ImageType[ImageType["promoIcon"] = 10] = "promoIcon";
-    ImageType[ImageType["chapter"] = 11] = "chapter";
-    ImageType[ImageType["authorDocument"] = 12] = "authorDocument";
-})(ImageType || (exports.ImageType = ImageType = {}));

package/build/enum/roles.d.ts

@@ -1,6 +0,0 @@
-export declare enum UserRoles {
-    superAdmin = 1,
-    admin = 2,
-    author = 3,
-    reader = 4
-}

package/build/enum/roles.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserRoles = void 0;
-var UserRoles;
-(function (UserRoles) {
-    UserRoles[UserRoles["superAdmin"] = 1] = "superAdmin";
-    UserRoles[UserRoles["admin"] = 2] = "admin";
-    UserRoles[UserRoles["author"] = 3] = "author";
-    UserRoles[UserRoles["reader"] = 4] = "reader";
-})(UserRoles || (exports.UserRoles = UserRoles = {}));

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

@@ -1,9 +0,0 @@
-import { CustomError } from './custom-error';
-export declare class BadRequestError extends CustomError {
-    message: string;
-    statusCode: number;
-    constructor(message: string);
-    serializeErrors(): {
-        message: string;
-    }[];
-}

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

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BadRequestError = void 0;
-const custom_error_1 = require("./custom-error");
-class BadRequestError extends custom_error_1.CustomError {
-    constructor(message) {
-        super(message);
-        this.message = message;
-        this.statusCode = 400;
-        Object.setPrototypeOf(this, BadRequestError.prototype);
-    }
-    serializeErrors() {
-        return [{ message: this.message }];
-    }
-}
-exports.BadRequestError = BadRequestError;

package/build/errors/conflict-error.d.ts

@@ -1,9 +0,0 @@
-import { CustomError } from './custom-error';
-export declare class ConflictError extends CustomError {
-    message: string;
-    statusCode: number;
-    constructor(message?: string);
-    serializeErrors(): {
-        message: string;
-    }[];
-}

package/build/errors/conflict-error.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConflictError = void 0;
-const custom_error_1 = require("./custom-error");
-class ConflictError extends custom_error_1.CustomError {
-    constructor(message = 'Internal Server Error') {
-        super(message);
-        this.message = message;
-        this.statusCode = 409;
-        Object.setPrototypeOf(this, ConflictError.prototype);
-    }
-    serializeErrors() {
-        return [{ message: this.message }];
-    }
-}
-exports.ConflictError = ConflictError;

package/build/errors/custom-error.d.ts

@@ -1,8 +0,0 @@
-export declare abstract class CustomError extends Error {
-    abstract statusCode: number;
-    constructor(message: string);
-    abstract serializeErrors(): {
-        message: string;
-        field?: string;
-    }[];
-}

package/build/errors/custom-error.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomError = void 0;
-class CustomError extends Error {
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, CustomError.prototype);
-    }
-}
-exports.CustomError = CustomError;

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

@@ -1,9 +0,0 @@
-import { CustomError } from './custom-error';
-export declare class DatabaseConnectionError extends CustomError {
-    statusCode: number;
-    reason: string;
-    constructor();
-    serializeErrors(): {
-        message: string;
-    }[];
-}