@nimbus-cqrs/core 2.0.0-beta.0

package/esm/lib/eventBus/eventBus.js

@@ -0,0 +1,473 @@
+import { metrics, SpanKind, SpanStatusCode, trace } from '@opentelemetry/api';
+import EventEmitter from 'node:events';
+import { GenericException } from '../exception/genericException.js';
+import { getLogger } from '../log/logger.js';
+const tracer = trace.getTracer('nimbus');
+const meter = metrics.getMeter('nimbus');
+const eventsPublishedCounter = meter.createCounter('eventbus_events_published_total', {
+    description: 'Total number of events published to the event bus',
+});
+const eventsDeliveredCounter = meter.createCounter('eventbus_events_delivered_total', {
+    description: 'Total number of events delivered to handlers',
+});
+const handlingDuration = meter.createHistogram('eventbus_event_handling_duration_seconds', {
+    description: 'Duration of event handler execution in seconds',
+    unit: 's',
+});
+const retryAttemptsCounter = meter.createCounter('eventbus_retry_attempts_total', {
+    description: 'Total number of retry attempts for event handling',
+});
+const eventSizeBytes = meter.createHistogram('eventbus_event_size_bytes', {
+    description: 'Size of events published to the event bus in bytes',
+    unit: 'By',
+});
+/**
+ * The NimbusEventBus is used to publish and subscribe to events within the application.
+ *
+ * Events are delivered asynchronously to all registered handlers. If a handler fails,
+ * it will be retried using exponential backoff until it succeeds or the maximum retry
+ * count is reached.
+ *
+ * All operations are instrumented with OpenTelemetry tracing and metrics for observability.
+ *
+ * @example
+ * ```ts
+ * import { createEvent, NimbusEventBus } from '@nimbus/core';
+ *
+ * const eventBus = new NimbusEventBus({
+ *     name: 'orders',
+ *     maxRetries: 3,
+ *     baseDelay: 1000,
+ *     maxDelay: 30000,
+ *     useJitter: true,
+ *     logPublish: (event) => {
+ *         console.log('Event published:', event.type, event.correlationid);
+ *     },
+ * });
+ *
+ * // Subscribe to events
+ * eventBus.subscribeEvent({
+ *     type: 'at.overlap.nimbus.order-created',
+ *     handler: async (event) => {
+ *         console.log('Order created:', event.data);
+ *     },
+ *     onError: (error, event) => {
+ *         console.error('Failed to handle event:', event.id, error.message);
+ *     },
+ *     options: {
+ *         maxRetries: 5,
+ *         baseDelay: 500,
+ *         maxDelay: 15000,
+ *         useJitter: true,
+ *     },
+ * });
+ *
+ * // Publish an event
+ * const event = createEvent({
+ *     type: 'at.overlap.nimbus.order-created',
+ *     source: 'https://api.example.com',
+ *     correlationid: '550e8400-e29b-41d4-a716-446655440000',
+ *     subject: '/orders/12345',
+ *     data: { orderId: '12345', customerId: '67890' },
+ *     datacontenttype: 'application/json',
+ * });
+ *
+ * eventBus.putEvent(event);
+ * ```
+ */
+export class NimbusEventBus {
+    _eventEmitter;
+    _name;
+    _maxRetries;
+    _baseDelay;
+    _maxDelay;
+    _useJitter;
+    _logPublish;
+    /**
+     * Create a new NimbusEventBus instance.
+     *
+     * @param options - The options for the event bus.
+     * @param options.name - The name of the event bus instance for metrics and traces. Defaults to 'default'.
+     * @param options.maxRetries - The maximum number of retries for handling the event in case of an error. Defaults to 2.
+     * @param options.baseDelay - The base delay for exponential backoff in milliseconds. Defaults to 1000ms.
+     * @param options.maxDelay - The maximum delay cap for exponential backoff in milliseconds. Defaults to 30000ms.
+     * @param options.useJitter - Whether to add jitter to the retry delay. Defaults to true.
+     * @param options.logPublish - Optional callback invoked when an event is published.
+     *
+     * @example
+     * ```ts
+     * import { getLogger, NimbusEventBus } from '@nimbus/core';
+     *
+     * const eventBus = new NimbusEventBus({
+     *     name: 'orders',
+     *     maxRetries: 3,
+     *     baseDelay: 1000,
+     *     maxDelay: 30000,
+     *     useJitter: true,
+     *     logPublish: (event) => {
+     *         getLogger().debug({
+     *             category: 'EventBus',
+     *             message: 'Published event',
+     *             data: { type: event.type, id: event.id },
+     *             correlationId: event.correlationid,
+     *         });
+     *     },
+     * });
+     * ```
+     */
+    constructor(options) {
+        this._eventEmitter = new EventEmitter();
+        this._name = options?.name ?? 'default';
+        this._maxRetries = options?.maxRetries ?? 2;
+        this._baseDelay = options?.baseDelay ?? 1000;
+        this._maxDelay = options?.maxDelay ?? 30000;
+        this._useJitter = options?.useJitter ?? true;
+        this._logPublish = options?.logPublish;
+    }
+    /**
+     * Publish an event to the event bus.
+     *
+     * The event is validated against the CloudEvents 64KB size limit before publishing.
+     * All subscribers registered for this event type will receive the event asynchronously.
+     *
+     * @param event - The CloudEvents-compliant event to publish.
+     * @throws {GenericException} If the event size exceeds 64KB.
+     *
+     * @example
+     * ```ts
+     * import { createEvent, getEventBus } from '@nimbus/core';
+     *
+     * const eventBus = getEventBus('default');
+     *
+     * // Create and publish an event with all CloudEvents properties
+     * const event = createEvent({
+     *     type: 'at.overlap.nimbus.order-created',
+     *     source: 'https://api.example.com',
+     *     correlationid: '550e8400-e29b-41d4-a716-446655440000',
+     *     subject: '/orders/12345',
+     *     data: {
+     *         orderId: '12345',
+     *         customerId: '67890',
+     *         items: ['item-1', 'item-2'],
+     *         total: 99.99,
+     *     },
+     *     datacontenttype: 'application/json',
+     *     dataschema: 'https://schemas.example.com/order-created.json',
+     * });
+     *
+     * eventBus.putEvent(event);
+     * ```
+     */
+    putEvent(event) {
+        const eventSize = this._validateEventSize(event);
+        const metricLabels = {
+            eventbus_name: this._name,
+            event_type: event.type,
+        };
+        tracer.startActiveSpan('eventbus.publish', {
+            kind: SpanKind.PRODUCER,
+            attributes: {
+                'messaging.system': 'nimbusEventBus',
+                'messaging.eventbus_name': this._name,
+                'messaging.operation': 'publish',
+                'messaging.destination': event.type,
+                'cloudevents.event_id': event.id,
+                'cloudevents.event_source': event.source,
+                ...(event.correlationid && {
+                    correlation_id: event.correlationid,
+                }),
+            },
+        }, (span) => {
+            try {
+                eventsPublishedCounter.add(1, metricLabels);
+                eventSizeBytes.record(eventSize, metricLabels);
+                if (this._logPublish) {
+                    this._logPublish(event);
+                }
+                this._eventEmitter.emit(event.type, event);
+            }
+            catch (error) {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: error instanceof Error
+                        ? error.message
+                        : 'Unknown error',
+                });
+                span.recordException(error instanceof Error
+                    ? error
+                    : new Error('Unknown error'));
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    /**
+     * Subscribe to an event type with a handler function.
+     *
+     * When an event matching the specified type is published, the handler is invoked.
+     * If the handler throws an error, it will be retried using exponential backoff
+     * (delay doubles with each attempt) until either it succeeds or the maximum retry
+     * count is reached.
+     *
+     * @param input - The subscription configuration.
+     * @param input.type - The CloudEvents event type to subscribe to.
+     * @param input.handler - The async handler function to process events.
+     * @param input.onError - Optional callback invoked when all retries are exhausted.
+     * @param input.options - Optional retry options to override EventBus defaults.
+     * @param input.options.maxRetries - Override maximum retry attempts for this subscription.
+     * @param input.options.baseDelay - Override base delay in milliseconds for this subscription.
+     * @param input.options.maxDelay - Override maximum delay cap in milliseconds for this subscription.
+     * @param input.options.useJitter - Override jitter setting for this subscription.
+     *
+     * @example
+     * ```ts
+     * import { getEventBus, getLogger } from '@nimbus/core';
+     *
+     * const eventBus = getEventBus('default');
+     *
+     * // Subscribe with all available options
+     * eventBus.subscribeEvent({
+     *     type: 'at.overlap.nimbus.order-created',
+     *     handler: async (event) => {
+     *         // Process the event
+     *         console.log('Order created:', event.data.orderId);
+     *         console.log('Correlation ID:', event.correlationid);
+     *     },
+     *     onError: (error, event) => {
+     *         getLogger().error({
+     *             category: 'OrderHandler',
+     *             message: 'Failed to process order after all retries',
+     *             data: { eventId: event.id, orderId: event.data.orderId },
+     *             error,
+     *             correlationId: event.correlationid,
+     *         });
+     *     },
+     *     options: {
+     *         maxRetries: 5,
+     *         baseDelay: 500,
+     *         maxDelay: 15000,
+     *         useJitter: true,
+     *     },
+     * });
+     * ```
+     */
+    subscribeEvent({ type, handler, onError, options, }) {
+        getLogger().debug({
+            category: 'Nimbus',
+            message: `Subscribed to ${type} event`,
+        });
+        const maxRetries = options?.maxRetries ?? this._maxRetries;
+        const baseDelay = options?.baseDelay ?? this._baseDelay;
+        const maxDelay = options?.maxDelay ?? this._maxDelay;
+        const useJitter = options?.useJitter ?? this._useJitter;
+        const handleEvent = async (event) => {
+            try {
+                await this._processEvent(handler, event, maxRetries, baseDelay, maxDelay, useJitter);
+            }
+            catch (error) {
+                if (onError) {
+                    onError(error, event);
+                }
+                else {
+                    getLogger().error({
+                        category: 'Nimbus',
+                        message: error.message,
+                        error,
+                    });
+                }
+            }
+        };
+        this._eventEmitter.on(type, handleEvent);
+    }
+    _processEvent(handler, event, maxRetries, baseDelay, maxDelay, useJitter) {
+        const startTime = performance.now();
+        const metricLabels = {
+            eventbus_name: this._name,
+            event_type: event.type,
+        };
+        return tracer.startActiveSpan('eventbus.handle', {
+            kind: SpanKind.CONSUMER,
+            attributes: {
+                'messaging.system': 'nimbusEventBus',
+                'messaging.eventbus_name': this._name,
+                'messaging.operation': 'process',
+                'messaging.destination': event.type,
+                'cloudevents.event_id': event.id,
+                'cloudevents.event_source': event.source,
+                ...(event.correlationid && {
+                    correlation_id: event.correlationid,
+                }),
+            },
+        }, async (span) => {
+            let attempt = 0;
+            while (attempt <= maxRetries) {
+                try {
+                    await handler(event);
+                    this._recordDeliveryMetrics(metricLabels, 'success', startTime);
+                    span.end();
+                    return;
+                }
+                catch (error) {
+                    attempt++;
+                    if (attempt > maxRetries) {
+                        this._handleFinalFailure({
+                            error,
+                            event,
+                            span,
+                            metricLabels,
+                            startTime,
+                            retryConfig: {
+                                maxRetries,
+                                baseDelay,
+                                maxDelay,
+                            },
+                        });
+                    }
+                    retryAttemptsCounter.add(1, metricLabels);
+                    const delayMs = this._calculateRetryDelay(attempt, baseDelay, maxDelay, useJitter);
+                    span.addEvent('retry', { attempt, delay_ms: delayMs });
+                    await new Promise((resolve) => setTimeout(resolve, delayMs));
+                }
+            }
+        });
+    }
+    _recordDeliveryMetrics(metricLabels, status, startTime) {
+        eventsDeliveredCounter.add(1, { ...metricLabels, status });
+        handlingDuration.record((performance.now() - startTime) / 1000, metricLabels);
+    }
+    _handleFinalFailure(options) {
+        const { error, event, span, metricLabels, startTime, retryConfig } = options;
+        this._recordDeliveryMetrics(metricLabels, 'error', startTime);
+        const errorMessage = error instanceof Error
+            ? error.message
+            : 'Unknown error';
+        const errorInstance = error instanceof Error
+            ? error
+            : new Error('Unknown error');
+        span.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
+        span.recordException(errorInstance);
+        span.end();
+        const exception = new GenericException(`Failed to handle event: ${event.type} from ${event.source}`, retryConfig);
+        if (error instanceof Error && error.stack) {
+            exception.stack = error.stack;
+        }
+        throw exception;
+    }
+    _calculateRetryDelay(attempt, baseDelay, maxDelay, useJitter) {
+        const delay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
+        const jitter = useJitter ? Math.random() * delay * 0.1 : 0;
+        return delay + jitter;
+    }
+    /**
+     * Validate the size of the event and return the size in bytes.
+     *
+     * To comply with the CloudEvent spec a transmitted event
+     * can only have a maximum size of 64KB.
+     *
+     * @param event - The event to validate.
+     * @returns The size of the event in bytes.
+     */
+    _validateEventSize(event) {
+        const eventJson = JSON.stringify(event);
+        const size = new TextEncoder().encode(eventJson).length;
+        const maxSizeBytes = 64 * 1024; // 64KB
+        if (size > maxSizeBytes) {
+            throw new GenericException(`Event size exceeds the limit of 64KB`, {
+                eventType: event.type,
+                eventSource: event.source,
+                eventSizeBytes: size,
+                maxSizeBytes,
+            });
+        }
+        return size;
+    }
+}
+/**
+ * Registry to store named EventBus instances.
+ */
+const eventBusRegistry = new Map();
+/**
+ * Setup a named EventBus instance and register it for later retrieval.
+ *
+ * Use this function to configure an EventBus with specific options at application
+ * startup, then retrieve it later using {@link getEventBus}.
+ *
+ * @param name - The unique name for this EventBus instance.
+ * @param options - Optional configuration options for the EventBus.
+ * @param options.maxRetries - The maximum number of retries for handling events. Defaults to 2.
+ * @param options.baseDelay - The base delay for exponential backoff in milliseconds. Defaults to 1000ms.
+ * @param options.maxDelay - The maximum delay cap for exponential backoff in milliseconds. Defaults to 30000ms.
+ * @param options.useJitter - Whether to add jitter to the retry delay. Defaults to true.
+ * @param options.logPublish - Optional callback invoked when an event is published.
+ *
+ * @example
+ * ```ts
+ * import { getLogger, setupEventBus } from '@nimbus/core';
+ *
+ * // At application startup, configure the event bus with all options
+ * setupEventBus('default', {
+ *     maxRetries: 3,
+ *     baseDelay: 1000,
+ *     maxDelay: 30000,
+ *     useJitter: true,
+ *     logPublish: (event) => {
+ *         getLogger().debug({
+ *             category: 'EventBus',
+ *             message: 'Published event',
+ *             data: { type: event.type, id: event.id },
+ *             correlationId: event.correlationid,
+ *         });
+ *     },
+ * });
+ * ```
+ */
+export const setupEventBus = (name, options) => {
+    eventBusRegistry.set(name, new NimbusEventBus({ ...options, name }));
+};
+/**
+ * Get a named EventBus instance.
+ *
+ * If an EventBus with the given name has been configured via {@link setupEventBus},
+ * that instance is returned. Otherwise, a new EventBus with default options is created
+ * and registered.
+ *
+ * @param name - The name of the EventBus instance to retrieve. Defaults to 'default'.
+ * @returns The NimbusEventBus instance.
+ *
+ * @example
+ * ```ts
+ * import { createEvent, getEventBus } from '@nimbus/core';
+ *
+ * // Get the event bus configured earlier with setupEventBus
+ * const eventBus = getEventBus('default');
+ *
+ * // Subscribe to events
+ * eventBus.subscribeEvent({
+ *     type: 'at.overlap.nimbus.order-created',
+ *     handler: async (event) => {
+ *         console.log('Order created:', event.data.orderId);
+ *     },
+ * });
+ *
+ * // Publish an event
+ * const event = createEvent({
+ *     type: 'at.overlap.nimbus.order-created',
+ *     source: 'https://api.example.com',
+ *     correlationid: '550e8400-e29b-41d4-a716-446655440000',
+ *     data: { orderId: '12345', customerId: '67890' },
+ *     datacontenttype: 'application/json',
+ * });
+ *
+ * eventBus.putEvent(event);
+ * ```
+ */
+export const getEventBus = (name = 'default') => {
+    let eventBus = eventBusRegistry.get(name);
+    if (!eventBus) {
+        eventBus = new NimbusEventBus({ name });
+        eventBusRegistry.set(name, eventBus);
+    }
+    return eventBus;
+};

package/esm/lib/exception/exception.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Base exception
+ */
+export declare class Exception extends Error {
+    details?: Record<string, unknown>;
+    statusCode?: number;
+    constructor(name: string, message: string, details?: Record<string, unknown>, statusCode?: number);
+    fromError(error: Error): Exception;
+}
+//# sourceMappingURL=exception.d.ts.map

package/esm/lib/exception/exception.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exception.d.ts","sourceRoot":"","sources":["../../../src/lib/exception/exception.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,SAAU,SAAQ,KAAK;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;gBAGvB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,UAAU,CAAC,EAAE,MAAM;IAmBhB,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS;CAM5C"}

package/esm/lib/exception/exception.js

@@ -0,0 +1,26 @@
+/**
+ * Base exception
+ */
+export class Exception extends Error {
+    details;
+    statusCode;
+    constructor(name, message, details, statusCode) {
+        super(message);
+        this.name = name;
+        if (details) {
+            this.details = details;
+        }
+        if (statusCode) {
+            this.statusCode = statusCode;
+        }
+        // Maintains proper stack trace in V8 environments
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    fromError(error) {
+        this.message = error.message;
+        this.stack = error.stack;
+        return this;
+    }
+}

package/esm/lib/exception/forbiddenException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from './exception.js';
+/**
+ * Forbidden exception
+ */
+export declare class ForbiddenException extends Exception {
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+//# sourceMappingURL=forbiddenException.d.ts.map

package/esm/lib/exception/forbiddenException.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forbiddenException.d.ts","sourceRoot":"","sources":["../../../src/lib/exception/forbiddenException.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,SAAS;gBACjC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAGlE"}

package/esm/lib/exception/forbiddenException.js

@@ -0,0 +1,9 @@
+import { Exception } from './exception.js';
+/**
+ * Forbidden exception
+ */
+export class ForbiddenException extends Exception {
+    constructor(message, details) {
+        super('FORBIDDEN', message ?? 'Forbidden', details, 403);
+    }
+}

package/esm/lib/exception/genericException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from './exception.js';
+/**
+ * Generic exception
+ */
+export declare class GenericException extends Exception {
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+//# sourceMappingURL=genericException.d.ts.map

package/esm/lib/exception/genericException.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"genericException.d.ts","sourceRoot":"","sources":["../../../src/lib/exception/genericException.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;gBAC/B,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAQlE"}

package/esm/lib/exception/genericException.js

@@ -0,0 +1,9 @@
+import { Exception } from './exception.js';
+/**
+ * Generic exception
+ */
+export class GenericException extends Exception {
+    constructor(message, details) {
+        super('INTERNAL_SERVER_ERROR', message ?? 'Internal server error', details, 500);
+    }
+}

package/esm/lib/exception/invalidInputException.d.ts

@@ -0,0 +1,18 @@
+import type { ZodError } from 'zod';
+import { Exception } from './exception.js';
+/**
+ * Invalid input exception
+ */
+export declare class InvalidInputException extends Exception {
+    constructor(message?: string, details?: Record<string, unknown>);
+    /**
+     * Takes a Zod error and creates an InvalidInputException from it.
+     * Takes care to preserve the stack and issues from the Zod error.
+     *
+     * @param {ZodError} error - The Zod error.
+     *
+     * @returns {InvalidInputException} The InvalidInputException.
+     */
+    fromZodError(error: ZodError): InvalidInputException;
+}
+//# sourceMappingURL=invalidInputException.d.ts.map

package/esm/lib/exception/invalidInputException.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidInputException.d.ts","sourceRoot":"","sources":["../../../src/lib/exception/invalidInputException.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,SAAS;gBACpC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAS/D;;;;;;;OAOG;IACI,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,qBAAqB;CAa9D"}

package/esm/lib/exception/invalidInputException.js

@@ -0,0 +1,28 @@
+import { Exception } from './exception.js';
+/**
+ * Invalid input exception
+ */
+export class InvalidInputException extends Exception {
+    constructor(message, details) {
+        super('INVALID_INPUT', message ?? 'Invalid input', details, 400);
+    }
+    /**
+     * Takes a Zod error and creates an InvalidInputException from it.
+     * Takes care to preserve the stack and issues from the Zod error.
+     *
+     * @param {ZodError} error - The Zod error.
+     *
+     * @returns {InvalidInputException} The InvalidInputException.
+     */
+    fromZodError(error) {
+        if (error.stack) {
+            this.stack = error.stack;
+        }
+        if (error.issues) {
+            this.details = {
+                issues: error.issues,
+            };
+        }
+        return this;
+    }
+}

package/esm/lib/exception/notFoundException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from './exception.js';
+/**
+ * Not found exception
+ */
+export declare class NotFoundException extends Exception {
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+//# sourceMappingURL=notFoundException.d.ts.map

package/esm/lib/exception/notFoundException.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notFoundException.d.ts","sourceRoot":"","sources":["../../../src/lib/exception/notFoundException.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;gBAChC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAGlE"}

package/esm/lib/exception/notFoundException.js

@@ -0,0 +1,9 @@
+import { Exception } from './exception.js';
+/**
+ * Not found exception
+ */
+export class NotFoundException extends Exception {
+    constructor(message, details) {
+        super('NOT_FOUND', message ?? 'Not found', details, 404);
+    }
+}

package/esm/lib/exception/unauthorizedException.d.ts

@@ -0,0 +1,8 @@
+import { Exception } from './exception.js';
+/**
+ * Unauthorized exception
+ */
+export declare class UnauthorizedException extends Exception {
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+//# sourceMappingURL=unauthorizedException.d.ts.map

package/esm/lib/exception/unauthorizedException.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unauthorizedException.d.ts","sourceRoot":"","sources":["../../../src/lib/exception/unauthorizedException.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,SAAS;gBACpC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAQlE"}

package/esm/lib/exception/unauthorizedException.js

@@ -0,0 +1,9 @@
+import { Exception } from './exception.js';
+/**
+ * Unauthorized exception
+ */
+export class UnauthorizedException extends Exception {
+    constructor(message, details) {
+        super('UNAUTHORIZED', message ?? 'Unauthorized', details, 401);
+    }
+}