ballrush-core 0.2.4 → 0.2.5

package/dist/errors/domain.errors.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Base error class for domain operations
+ */
+export declare class DomainError extends Error {
+    readonly entityType: string;
+    readonly operation: string;
+    constructor(message: string, entityType: string, operation: string);
+}
+/**
+ * Error thrown when domain validation fails
+ */
+export declare class DomainValidationError extends DomainError {
+    constructor(entityType: string, field: string, value: any, reason: string);
+}
+/**
+ * Error thrown when a business rule is violated
+ */
+export declare class BusinessRuleViolationError extends DomainError {
+    constructor(entityType: string, rule: string, context?: string);
+}

package/dist/errors/domain.errors.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BusinessRuleViolationError = exports.DomainValidationError = exports.DomainError = void 0;
+/**
+ * Base error class for domain operations
+ */
+class DomainError extends Error {
+    constructor(message, entityType, operation) {
+        super(message);
+        this.entityType = entityType;
+        this.operation = operation;
+        this.name = 'DomainError';
+    }
+}
+exports.DomainError = DomainError;
+/**
+ * Error thrown when domain validation fails
+ */
+class DomainValidationError extends DomainError {
+    constructor(entityType, field, value, reason) {
+        super(`Domain validation failed for ${entityType}.${field}: ${reason} (value: ${value})`, entityType, 'validate');
+        this.name = 'DomainValidationError';
+    }
+}
+exports.DomainValidationError = DomainValidationError;
+/**
+ * Error thrown when a business rule is violated
+ */
+class BusinessRuleViolationError extends DomainError {
+    constructor(entityType, rule, context) {
+        super(`Business rule violation in ${entityType}: ${rule}${context ? ` (${context})` : ''}`, entityType, 'business_rule');
+        this.name = 'BusinessRuleViolationError';
+    }
+}
+exports.BusinessRuleViolationError = BusinessRuleViolationError;

package/dist/errors/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./repository.errors";
+export * from "./domain.errors";

package/dist/errors/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./repository.errors"), exports);
+__exportStar(require("./domain.errors"), exports);

package/dist/errors/repository.errors.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Base error class for repository operations
+ */
+export declare class RepositoryError extends Error {
+    readonly operation: string;
+    readonly entityType: string;
+    readonly originalError?: Error | undefined;
+    constructor(message: string, operation: string, entityType: string, originalError?: Error | undefined);
+}
+/**
+ * Error thrown when a database connection fails
+ */
+export declare class DatabaseConnectionError extends RepositoryError {
+    constructor(originalError?: Error);
+}
+/**
+ * Error thrown when a query fails
+ */
+export declare class QueryError extends RepositoryError {
+    constructor(operation: string, entityType: string, identifier: string | number, originalError?: Error);
+}
+/**
+ * Error thrown when an entity is not found
+ */
+export declare class EntityNotFoundError extends RepositoryError {
+    constructor(entityType: string, identifier: string | number, operation?: string);
+}
+/**
+ * Error thrown when a duplicate entity is created
+ */
+export declare class DuplicateEntityError extends RepositoryError {
+    constructor(entityType: string, identifier: string | number, originalError?: Error);
+}
+/**
+ * Error thrown when validation fails
+ */
+export declare class ValidationError extends RepositoryError {
+    constructor(entityType: string, field: string, value: any, reason: string);
+}
+/**
+ * Error thrown when a transaction fails
+ */
+export declare class TransactionError extends RepositoryError {
+    constructor(operation: string, originalError?: Error);
+}

package/dist/errors/repository.errors.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionError = exports.ValidationError = exports.DuplicateEntityError = exports.EntityNotFoundError = exports.QueryError = exports.DatabaseConnectionError = exports.RepositoryError = void 0;
+/**
+ * Base error class for repository operations
+ */
+class RepositoryError extends Error {
+    constructor(message, operation, entityType, originalError) {
+        super(message);
+        this.operation = operation;
+        this.entityType = entityType;
+        this.originalError = originalError;
+        this.name = 'RepositoryError';
+    }
+}
+exports.RepositoryError = RepositoryError;
+/**
+ * Error thrown when a database connection fails
+ */
+class DatabaseConnectionError extends RepositoryError {
+    constructor(originalError) {
+        super('Failed to connect to database', 'connect', 'database', originalError);
+        this.name = 'DatabaseConnectionError';
+    }
+}
+exports.DatabaseConnectionError = DatabaseConnectionError;
+/**
+ * Error thrown when a query fails
+ */
+class QueryError extends RepositoryError {
+    constructor(operation, entityType, identifier, originalError) {
+        super(`Query failed for ${entityType} with identifier ${identifier}`, operation, entityType, originalError);
+        this.name = 'QueryError';
+    }
+}
+exports.QueryError = QueryError;
+/**
+ * Error thrown when an entity is not found
+ */
+class EntityNotFoundError extends RepositoryError {
+    constructor(entityType, identifier, operation = 'find') {
+        super(`${entityType} with identifier ${identifier} not found`, operation, entityType);
+        this.name = 'EntityNotFoundError';
+    }
+}
+exports.EntityNotFoundError = EntityNotFoundError;
+/**
+ * Error thrown when a duplicate entity is created
+ */
+class DuplicateEntityError extends RepositoryError {
+    constructor(entityType, identifier, originalError) {
+        super(`${entityType} with identifier ${identifier} already exists`, 'create', entityType, originalError);
+        this.name = 'DuplicateEntityError';
+    }
+}
+exports.DuplicateEntityError = DuplicateEntityError;
+/**
+ * Error thrown when validation fails
+ */
+class ValidationError extends RepositoryError {
+    constructor(entityType, field, value, reason) {
+        super(`Validation failed for ${entityType}.${field}: ${reason} (value: ${value})`, 'validate', entityType);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Error thrown when a transaction fails
+ */
+class TransactionError extends RepositoryError {
+    constructor(operation, originalError) {
+        super(`Transaction failed during ${operation}`, operation, 'transaction', originalError);
+        this.name = 'TransactionError';
+    }
+}
+exports.TransactionError = TransactionError;

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export * from "./domain";
 export * from "./ports";
 export * from "./mongo";
 export * from "./repositories";
+export * from "./errors";

package/dist/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./domain"), exports);
 __exportStar(require("./ports"), exports);
 __exportStar(require("./mongo"), exports);
 __exportStar(require("./repositories"), exports);
+__exportStar(require("./errors"), exports);

package/dist/repositories/mongo/event-template.repository.js

@@ -2,38 +2,122 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoEventTemplatesRepository = void 0;
 const event_template_mapper_1 = require("./event-template.mapper");
+const errors_1 = require("../../errors");
 class MongoEventTemplatesRepository {
     constructor(Model) {
         this.Model = Model;
     }
     async getById(templateId) {
-        const doc = await this.Model.findOne({ templateId }).lean();
-        return doc ? (0, event_template_mapper_1.toDomain)(doc) : null;
+        try {
+            if (!templateId || templateId === 0) {
+                throw new errors_1.ValidationError('EventTemplate', 'templateId', templateId, 'must be a non-zero number');
+            }
+            const doc = await this.Model.findOne({ templateId }).lean();
+            return doc ? (0, event_template_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('getById', 'EventTemplate', templateId, error);
+        }
     }
     async getByGroupId(groupId) {
-        const docs = await this.Model.find({ groupId }).lean();
-        return docs.map(d => (0, event_template_mapper_1.toDomain)(d));
+        try {
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('EventTemplate', 'groupId', groupId, 'must be a non-zero number');
+            }
+            const docs = await this.Model.find({ groupId }).lean();
+            return docs.map(d => (0, event_template_mapper_1.toDomain)(d));
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('getByGroupId', 'EventTemplate', groupId, error);
+        }
     }
     async getAll() {
-        const docs = await this.Model.find().lean();
-        return docs.map(d => (0, event_template_mapper_1.toDomain)(d));
+        try {
+            const docs = await this.Model.find().lean();
+            return docs.map(d => (0, event_template_mapper_1.toDomain)(d));
+        }
+        catch (error) {
+            throw new errors_1.QueryError('getAll', 'EventTemplate', 'all', error);
+        }
     }
     async createFromDomain(entity) {
-        const write = (0, event_template_mapper_1.toDoc)(entity);
-        const saved = await new this.Model(write).save();
-        return (0, event_template_mapper_1.toDomain)(saved.toObject());
+        try {
+            if (!entity) {
+                throw new errors_1.ValidationError('EventTemplate', 'entity', entity, 'entity object is required');
+            }
+            const templateId = entity.getTemplateId();
+            if (!templateId || templateId === 0) {
+                throw new errors_1.ValidationError('EventTemplate', 'templateId', templateId, 'must be a non-zero number');
+            }
+            const write = (0, event_template_mapper_1.toDoc)(entity);
+            const saved = await new this.Model(write).save();
+            return (0, event_template_mapper_1.toDomain)(saved.toObject());
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            if (error?.code === 11000) {
+                throw new errors_1.DuplicateEntityError('EventTemplate', entity.getTemplateId(), error);
+            }
+            throw new errors_1.QueryError('createFromDomain', 'EventTemplate', entity.getTemplateId(), error);
+        }
     }
     async updateFromDomain(entity) {
-        const write = (0, event_template_mapper_1.toDoc)(entity);
-        const updated = await this.Model.findOneAndUpdate({ templateId: entity.getTemplateId() }, write, { new: true }).lean();
-        return updated ? (0, event_template_mapper_1.toDomain)(updated) : null;
+        try {
+            if (!entity) {
+                throw new errors_1.ValidationError('EventTemplate', 'entity', entity, 'entity object is required');
+            }
+            const templateId = entity.getTemplateId();
+            if (!templateId || templateId === 0) {
+                throw new errors_1.ValidationError('EventTemplate', 'templateId', templateId, 'must be a non-zero number');
+            }
+            const write = (0, event_template_mapper_1.toDoc)(entity);
+            const updated = await this.Model.findOneAndUpdate({ templateId }, write, { new: true }).lean();
+            return updated ? (0, event_template_mapper_1.toDomain)(updated) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('updateFromDomain', 'EventTemplate', entity.getTemplateId(), error);
+        }
     }
     async deleteById(templateId) {
-        await this.Model.deleteOne({ templateId });
+        try {
+            if (!templateId || templateId === 0) {
+                throw new errors_1.ValidationError('EventTemplate', 'templateId', templateId, 'must be a non-zero number');
+            }
+            const result = await this.Model.deleteOne({ templateId });
+            if (result.deletedCount === 0) {
+                throw new errors_1.EntityNotFoundError('EventTemplate', templateId, 'delete');
+            }
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError || error instanceof errors_1.EntityNotFoundError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('deleteById', 'EventTemplate', templateId, error);
+        }
     }
     async setDefaultParticipants(templateId, participants) {
-        const doc = await this.Model.findOneAndUpdate({ templateId }, { $set: { defaultParticipants: participants } }, { new: true }).lean();
-        return doc ? (0, event_template_mapper_1.toDomain)(doc) : null;
+        try {
+            if (!templateId || templateId === 0) {
+                throw new errors_1.ValidationError('EventTemplate', 'templateId', templateId, 'must be a non-zero number');
+            }
+            if (!Array.isArray(participants)) {
+                throw new errors_1.ValidationError('EventTemplate', 'participants', participants, 'must be an array');
+            }
+            const doc = await this.Model.findOneAndUpdate({ templateId }, { $set: { defaultParticipants: participants } }, { new: true }).lean();
+            return doc ? (0, event_template_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('setDefaultParticipants', 'EventTemplate', templateId, error);
+        }
     }
 }
 exports.MongoEventTemplatesRepository = MongoEventTemplatesRepository;

package/dist/repositories/mongo/event.repository.js

@@ -2,53 +2,162 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoEventsRepository = void 0;
 const event_mapper_1 = require("./event.mapper");
+const errors_1 = require("../../errors");
 class MongoEventsRepository {
     constructor(EventModel) {
         this.EventModel = EventModel;
     }
     async create(event) {
-        const write = (0, event_mapper_1.toDoc)(event);
-        const saved = await new this.EventModel(write).save();
-        return (0, event_mapper_1.toDomain)(saved.toObject());
+        try {
+            // Validate input
+            if (!event) {
+                throw new errors_1.ValidationError('Event', 'event', event, 'event object is required');
+            }
+            const eventId = event.getEventId();
+            if (!eventId || eventId === 0) {
+                throw new errors_1.ValidationError('Event', 'eventId', eventId, 'must be a non-zero number');
+            }
+            const write = (0, event_mapper_1.toDoc)(event);
+            const saved = await new this.EventModel(write).save();
+            return (0, event_mapper_1.toDomain)(saved.toObject());
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            // Check for duplicate key error
+            if (error?.code === 11000) {
+                throw new errors_1.DuplicateEntityError('Event', event.getEventId(), error);
+            }
+            throw new errors_1.QueryError('create', 'Event', event.getEventId(), error);
+        }
     }
     async findById(eventId) {
-        const doc = await this.EventModel.findOne({ eventId }).lean();
-        return doc ? (0, event_mapper_1.toDomain)(doc) : null;
+        try {
+            // Validate input
+            if (!eventId || eventId === 0) {
+                throw new errors_1.ValidationError('Event', 'eventId', eventId, 'must be a non-zero number');
+            }
+            const doc = await this.EventModel.findOne({ eventId }).lean();
+            return doc ? (0, event_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('findById', 'Event', eventId, error);
+        }
     }
     async findByGroupAndStatuses(groupId, statuses) {
-        const doc = await this.EventModel.findOne({ groupId, status: { $in: statuses } }).lean();
-        return doc ? (0, event_mapper_1.toDomain)(doc) : null;
+        try {
+            // Validate input
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('Event', 'groupId', groupId, 'must be a non-zero number');
+            }
+            if (!statuses || !Array.isArray(statuses) || statuses.length === 0) {
+                throw new errors_1.ValidationError('Event', 'statuses', statuses, 'must be a non-empty array');
+            }
+            const doc = await this.EventModel.findOne({ groupId, status: { $in: statuses } }).lean();
+            return doc ? (0, event_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('findByGroupAndStatuses', 'Event', groupId, error);
+        }
     }
     async findByTemplateAndGroup(templateId, groupId) {
-        const doc = await this.EventModel.findOne({ templateId, groupId, status: "active" }).lean();
-        return doc ? (0, event_mapper_1.toDomain)(doc) : null;
+        try {
+            if (!templateId || templateId === 0) {
+                throw new errors_1.ValidationError('Event', 'templateId', templateId, 'must be a non-zero number');
+            }
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('Event', 'groupId', groupId, 'must be a non-zero number');
+            }
+            const doc = await this.EventModel.findOne({ templateId, groupId, status: "active" }).lean();
+            return doc ? (0, event_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('findByTemplateAndGroup', 'Event', `${templateId}-${groupId}`, error);
+        }
     }
     async update(eventId, updates) {
-        const write = (0, event_mapper_1.toDoc)(updates);
-        const doc = await this.EventModel.findOneAndUpdate({ eventId }, { $set: write }, { new: true }).lean();
-        return doc ? (0, event_mapper_1.toDomain)(doc) : null;
+        try {
+            if (!eventId || eventId === 0) {
+                throw new errors_1.ValidationError('Event', 'eventId', eventId, 'must be a non-zero number');
+            }
+            if (!updates) {
+                throw new errors_1.ValidationError('Event', 'updates', updates, 'updates object is required');
+            }
+            const write = (0, event_mapper_1.toDoc)(updates);
+            const doc = await this.EventModel.findOneAndUpdate({ eventId }, { $set: write }, { new: true }).lean();
+            return doc ? (0, event_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('update', 'Event', eventId, error);
+        }
     }
     async findLastByGroup(groupId) {
-        const doc = await this.EventModel.findOne({ groupId }).sort({ date: -1 }).lean();
-        return doc ? (0, event_mapper_1.toDomain)(doc) : null;
+        try {
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('Event', 'groupId', groupId, 'must be a non-zero number');
+            }
+            const doc = await this.EventModel.findOne({ groupId }).sort({ date: -1 }).lean();
+            return doc ? (0, event_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('findLastByGroup', 'Event', groupId, error);
+        }
     }
     async findAllByGroup(groupId) {
-        const docs = await this.EventModel.find({ groupId }).lean();
-        return docs.map(d => (0, event_mapper_1.toDomain)(d));
+        try {
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('Event', 'groupId', groupId, 'must be a non-zero number');
+            }
+            const docs = await this.EventModel.find({ groupId }).lean();
+            return docs.map(d => (0, event_mapper_1.toDomain)(d));
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError)
+                throw error;
+            throw new errors_1.QueryError('findAllByGroup', 'Event', groupId, error);
+        }
     }
     async countEvents() {
-        return this.EventModel.countDocuments();
+        try {
+            return await this.EventModel.countDocuments();
+        }
+        catch (error) {
+            throw new errors_1.QueryError('countEvents', 'Event', 'all', error);
+        }
     }
     async countMatches() {
-        const result = await this.EventModel.aggregate([
-            { $unwind: "$matches" },
-            { $count: "matches" }
-        ]);
-        return result.length > 0 ? result[0].matches : 0;
+        try {
+            const result = await this.EventModel.aggregate([
+                { $unwind: "$matches" },
+                { $count: "matches" }
+            ]);
+            return result.length > 0 ? result[0].matches : 0;
+        }
+        catch (error) {
+            throw new errors_1.QueryError('countMatches', 'Event', 'all', error);
+        }
     }
     async getAll() {
-        const docs = await this.EventModel.find().lean();
-        return docs.map(d => (0, event_mapper_1.toDomain)(d));
+        try {
+            const docs = await this.EventModel.find().lean();
+            return docs.map(d => (0, event_mapper_1.toDomain)(d));
+        }
+        catch (error) {
+            throw new errors_1.QueryError('getAll', 'Event', 'all', error);
+        }
     }
 }
 exports.MongoEventsRepository = MongoEventsRepository;

package/dist/repositories/mongo/group.repository.js

@@ -2,30 +2,99 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoGroupsRepository = void 0;
 const group_mapper_1 = require("./group.mapper");
+const errors_1 = require("../../errors");
 class MongoGroupsRepository {
     constructor(GroupModel) {
         this.GroupModel = GroupModel;
     }
     async create(group) {
-        const write = (0, group_mapper_1.toDoc)(group);
-        const saved = await new this.GroupModel(write).save();
-        return (0, group_mapper_1.toDomain)(saved.toObject());
+        try {
+            // Validate input
+            if (!group) {
+                throw new errors_1.ValidationError('Group', 'group', group, 'group object is required');
+            }
+            const groupId = group.getGroupId();
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('Group', 'groupId', groupId, 'must be a non-zero number');
+            }
+            const write = (0, group_mapper_1.toDoc)(group);
+            const saved = await new this.GroupModel(write).save();
+            return (0, group_mapper_1.toDomain)(saved.toObject());
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            // Check for duplicate key error
+            if (error?.code === 11000) {
+                throw new errors_1.DuplicateEntityError('Group', group.getGroupId(), error);
+            }
+            throw new errors_1.QueryError('create', 'Group', group.getGroupId(), error);
+        }
     }
     async findById(groupId) {
-        const doc = await this.GroupModel.findOne({ groupId }).lean();
-        return doc ? (0, group_mapper_1.toDomain)(doc) : null;
+        try {
+            // Validate input
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('Group', 'groupId', groupId, 'must be a non-zero number');
+            }
+            const doc = await this.GroupModel.findOne({ groupId }).lean();
+            return doc ? (0, group_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('findById', 'Group', groupId, error);
+        }
     }
     async update(groupId, updates) {
-        const write = (0, group_mapper_1.toDoc)(updates);
-        const doc = await this.GroupModel.findOneAndUpdate({ groupId }, { $set: write }, { new: true }).lean();
-        return doc ? (0, group_mapper_1.toDomain)(doc) : null;
+        try {
+            // Validate input
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('Group', 'groupId', groupId, 'must be a non-zero number');
+            }
+            if (!updates) {
+                throw new errors_1.ValidationError('Group', 'updates', updates, 'updates object is required');
+            }
+            const write = (0, group_mapper_1.toDoc)(updates);
+            const doc = await this.GroupModel.findOneAndUpdate({ groupId }, { $set: write }, { new: true }).lean();
+            return doc ? (0, group_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('update', 'Group', groupId, error);
+        }
     }
     async findAll() {
-        const docs = await this.GroupModel.find().lean();
-        return docs.map((doc) => (0, group_mapper_1.toDomain)(doc));
+        try {
+            const docs = await this.GroupModel.find().lean();
+            return docs.map((doc) => (0, group_mapper_1.toDomain)(doc));
+        }
+        catch (error) {
+            throw new errors_1.QueryError('findAll', 'Group', 'all', error);
+        }
     }
     async delete(groupId) {
-        await this.GroupModel.deleteOne({ groupId });
+        try {
+            // Validate input
+            if (!groupId || groupId === 0) {
+                throw new errors_1.ValidationError('Group', 'groupId', groupId, 'must be a non-zero number');
+            }
+            const result = await this.GroupModel.deleteOne({ groupId });
+            // Check if document was actually deleted
+            if (result.deletedCount === 0) {
+                throw new errors_1.EntityNotFoundError('Group', groupId, 'delete');
+            }
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError || error instanceof errors_1.EntityNotFoundError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('delete', 'Group', groupId, error);
+        }
     }
 }
 exports.MongoGroupsRepository = MongoGroupsRepository;

package/dist/repositories/mongo/user.repository.js

@@ -2,23 +2,66 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoUsersRepository = void 0;
 const user_mapper_1 = require("./user.mapper");
+const errors_1 = require("../../errors");
 class MongoUsersRepository {
     constructor(UserModel) {
         this.UserModel = UserModel;
     }
     async findByUserId(userId) {
-        const doc = await this.UserModel.findOne({ userId }).lean();
-        return doc ? (0, user_mapper_1.toDomain)(doc) : null;
+        try {
+            // Validate input
+            if (!userId || userId === 0) {
+                throw new errors_1.ValidationError('User', 'userId', userId, 'must be a non-zero number');
+            }
+            const doc = await this.UserModel.findOne({ userId }).lean();
+            return doc ? (0, user_mapper_1.toDomain)(doc) : null;
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            throw new errors_1.QueryError('findByUserId', 'User', userId, error);
+        }
     }
     async upsert(user) {
-        await this.UserModel.updateOne({ userId: user.getUserId() }, { $set: (0, user_mapper_1.toDoc)(user) }, { upsert: true });
+        try {
+            // Validate input
+            if (!user) {
+                throw new errors_1.ValidationError('User', 'user', user, 'user object is required');
+            }
+            const userId = user.getUserId();
+            if (!userId || userId === 0) {
+                throw new errors_1.ValidationError('User', 'userId', userId, 'must be a non-zero number');
+            }
+            await this.UserModel.updateOne({ userId }, { $set: (0, user_mapper_1.toDoc)(user) }, { upsert: true });
+        }
+        catch (error) {
+            if (error instanceof errors_1.ValidationError) {
+                throw error;
+            }
+            // Check for duplicate key error
+            if (error?.code === 11000) {
+                throw new errors_1.DuplicateEntityError('User', user.getUserId(), error);
+            }
+            throw new errors_1.QueryError('upsert', 'User', user.getUserId(), error);
+        }
     }
     async count() {
-        return this.UserModel.countDocuments();
+        try {
+            return await this.UserModel.countDocuments();
+        }
+        catch (error) {
+            throw new errors_1.QueryError('count', 'User', 'all', error);
+        }
     }
     async findAll() {
-        const docs = await this.UserModel.find().lean();
-        return docs.map(d => (0, user_mapper_1.toDomain)(d));
+        try {
+            const docs = await this.UserModel.find().lean();
+            return docs.map(d => (0, user_mapper_1.toDomain)(d));
+        }
+        catch (error) {
+            throw new errors_1.QueryError('findAll', 'User', 'all', error);
+        }
     }
 }
 exports.MongoUsersRepository = MongoUsersRepository;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ballrush-core",
-    "version": "0.2.4",
+    "version": "0.2.5",
     "private": false,
     "license": "MIT",
     "main": "./dist/index.js",