@beethovn/errors 1.0.0

package/dist/integration/IntegrationError.js

@@ -0,0 +1,111 @@
+import { BeethovnError } from '../base/BeethovnError.js';
+/**
+ * Base class for integration errors
+ *
+ * Integration errors represent failures in event publishing, message queues,
+ * and other inter-service communication mechanisms.
+ */
+export class IntegrationError extends BeethovnError {
+    constructor(message, code, metadata = {}, recoverable = true) {
+        super(message, code, 503, metadata, recoverable);
+    }
+}
+/**
+ * Event publishing error
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await eventBus.publish(event);
+ * } catch (error: unknown) {
+ *   throw new EventPublishError(event.type, error, { eventId: event.id });
+ * }
+ * ```
+ */
+export class EventPublishError extends IntegrationError {
+    constructor(eventType, originalError, metadata = {}) {
+        const errorMessage = originalError instanceof Error
+            ? originalError.message
+            : String(originalError);
+        super(`Failed to publish event: ${eventType}`, 'EVENT_PUBLISH_ERROR', {
+            ...metadata,
+            eventType,
+            originalError: errorMessage,
+        }, true);
+    }
+}
+/**
+ * Message queue error
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await messageQueue.send(message);
+ * } catch (error: unknown) {
+ *   throw new MessageQueueError('send', 'payment-queue', error);
+ * }
+ * ```
+ */
+export class MessageQueueError extends IntegrationError {
+    constructor(operation, queue, originalError, metadata = {}) {
+        const errorMessage = originalError instanceof Error
+            ? originalError.message
+            : String(originalError);
+        super(`Message queue ${operation} failed on ${queue}: ${errorMessage}`, 'MESSAGE_QUEUE_ERROR', {
+            ...metadata,
+            operation,
+            queue,
+            originalError: errorMessage,
+        }, true);
+    }
+}
+/**
+ * WebSocket connection error
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await ws.connect();
+ * } catch (error: unknown) {
+ *   throw new WebSocketError('connect', error, { url });
+ * }
+ * ```
+ */
+export class WebSocketError extends IntegrationError {
+    constructor(operation, originalError, metadata = {}) {
+        const errorMessage = originalError instanceof Error
+            ? originalError.message
+            : String(originalError);
+        super(`WebSocket ${operation} failed: ${errorMessage}`, 'WEBSOCKET_ERROR', {
+            ...metadata,
+            operation,
+            originalError: errorMessage,
+        }, true);
+    }
+}
+/**
+ * Event subscription error
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   eventBus.subscribe('OrderCreated', handler);
+ * } catch (error: unknown) {
+ *   throw new EventSubscriptionError('OrderCreated', error);
+ * }
+ * ```
+ */
+export class EventSubscriptionError extends IntegrationError {
+    constructor(eventType, originalError, metadata = {}) {
+        const errorMessage = originalError instanceof Error
+            ? originalError.message
+            : String(originalError);
+        super(`Failed to subscribe to event: ${eventType}`, 'EVENT_SUBSCRIPTION_ERROR', {
+            ...metadata,
+            eventType,
+            originalError: errorMessage,
+        }, false // Subscriptions should fail fast, not retry
+        );
+    }
+}
+//# sourceMappingURL=IntegrationError.js.map

package/dist/integration/IntegrationError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntegrationError.js","sourceRoot":"","sources":["../../src/integration/IntegrationError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEzD;;;;;GAKG;AACH,MAAM,OAAgB,gBAAiB,SAAQ,aAAa;IAC1D,YACE,OAAe,EACf,IAAY,EACZ,WAAoC,EAAE,EACtC,cAAuB,IAAI;QAE3B,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;IACnD,CAAC;CACF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,iBAAkB,SAAQ,gBAAgB;IACrD,YACE,SAAiB,EACjB,aAAuB,EACvB,WAAoC,EAAE;QAEtC,MAAM,YAAY,GAAG,aAAa,YAAY,KAAK;YACjD,CAAC,CAAC,aAAa,CAAC,OAAO;YACvB,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QAE1B,KAAK,CACH,4BAA4B,SAAS,EAAE,EACvC,qBAAqB,EACrB;YACE,GAAG,QAAQ;YACX,SAAS;YACT,aAAa,EAAE,YAAY;SAC5B,EACD,IAAI,CACL,CAAC;IACJ,CAAC;CACF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,iBAAkB,SAAQ,gBAAgB;IACrD,YACE,SAAiB,EACjB,KAAa,EACb,aAAuB,EACvB,WAAoC,EAAE;QAEtC,MAAM,YAAY,GAAG,aAAa,YAAY,KAAK;YACjD,CAAC,CAAC,aAAa,CAAC,OAAO;YACvB,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QAE1B,KAAK,CACH,iBAAiB,SAAS,cAAc,KAAK,KAAK,YAAY,EAAE,EAChE,qBAAqB,EACrB;YACE,GAAG,QAAQ;YACX,SAAS;YACT,KAAK;YACL,aAAa,EAAE,YAAY;SAC5B,EACD,IAAI,CACL,CAAC;IACJ,CAAC;CACF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,cAAe,SAAQ,gBAAgB;IAClD,YACE,SAAiB,EACjB,aAAuB,EACvB,WAAoC,EAAE;QAEtC,MAAM,YAAY,GAAG,aAAa,YAAY,KAAK;YACjD,CAAC,CAAC,aAAa,CAAC,OAAO;YACvB,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QAE1B,KAAK,CACH,aAAa,SAAS,YAAY,YAAY,EAAE,EAChD,iBAAiB,EACjB;YACE,GAAG,QAAQ;YACX,SAAS;YACT,aAAa,EAAE,YAAY;SAC5B,EACD,IAAI,CACL,CAAC;IACJ,CAAC;CACF;AAED;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,sBAAuB,SAAQ,gBAAgB;IAC1D,YACE,SAAiB,EACjB,aAAuB,EACvB,WAAoC,EAAE;QAEtC,MAAM,YAAY,GAAG,aAAa,YAAY,KAAK;YACjD,CAAC,CAAC,aAAa,CAAC,OAAO;YACvB,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QAE1B,KAAK,CACH,iCAAiC,SAAS,EAAE,EAC5C,0BAA0B,EAC1B;YACE,GAAG,QAAQ;YACX,SAAS;YACT,aAAa,EAAE,YAAY;SAC5B,EACD,KAAK,CAAC,4CAA4C;SACnD,CAAC;IACJ,CAAC;CACF"}

package/dist/utils/errorFactory.d.ts

@@ -0,0 +1,96 @@
+import { BeethovnError } from '../base/BeethovnError.js';
+import { ValidationError } from '../domain/DomainError.js';
+import { DatabaseError, NetworkError } from '../infrastructure/InfrastructureError.js';
+/**
+ * Factory for creating typed errors from unknown errors
+ *
+ * Provides consistent error creation patterns and converts
+ * unknown errors into structured BeethovnError instances.
+ */
+export declare class ErrorFactory {
+    /**
+     * Create appropriate error from unknown error
+     *
+     * @param error - The unknown error to convert
+     * @param context - Optional context string for debugging
+     * @returns Structured BeethovnError instance
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await operation();
+     * } catch (error: unknown) {
+     *   throw ErrorFactory.fromUnknown(error, 'processPayment');
+     * }
+     * ```
+     */
+    static fromUnknown(error: unknown, context?: string): BeethovnError;
+    /**
+     * Wrap database errors
+     *
+     * @param operation - The database operation that failed
+     * @param error - The original error
+     * @param metadata - Additional context
+     * @returns DatabaseError instance
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await db.query(sql, params);
+     * } catch (error: unknown) {
+     *   throw ErrorFactory.database('saveUser', error, { userId });
+     * }
+     * ```
+     */
+    static database(operation: string, error: unknown, metadata?: Record<string, unknown>): DatabaseError;
+    /**
+     * Create validation error with field
+     *
+     * @param message - Error message
+     * @param field - Field that failed validation
+     * @param metadata - Additional context
+     * @returns ValidationError instance
+     *
+     * @example
+     * ```typescript
+     * if (!email.includes('@')) {
+     *   throw ErrorFactory.validation('Invalid email format', 'email');
+     * }
+     * ```
+     */
+    static validation(message: string, field?: string, metadata?: Record<string, unknown>): ValidationError;
+    /**
+     * Create network error
+     *
+     * @param message - Error message
+     * @param metadata - Additional context (url, method, etc.)
+     * @returns NetworkError instance
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await fetch(url);
+     * } catch (error: unknown) {
+     *   throw ErrorFactory.network('Failed to fetch data', { url, method: 'GET' });
+     * }
+     * ```
+     */
+    static network(message: string, metadata?: Record<string, unknown>): NetworkError;
+    /**
+     * Convert multiple errors into a single aggregated error
+     *
+     * @param errors - Array of errors to aggregate
+     * @param context - Context for the aggregated error
+     * @returns Single BeethovnError with all errors in metadata
+     *
+     * @example
+     * ```typescript
+     * const errors = validateUser(data);
+     * if (errors.length > 0) {
+     *   throw ErrorFactory.aggregate(errors, 'User validation');
+     * }
+     * ```
+     */
+    static aggregate(errors: BeethovnError[], context: string): BeethovnError;
+}
+//# sourceMappingURL=errorFactory.d.ts.map

package/dist/utils/errorFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorFactory.d.ts","sourceRoot":"","sources":["../../src/utils/errorFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,YAAY,EAAgB,MAAM,0CAA0C,CAAC;AAErG;;;;;GAKG;AACH,qBAAa,YAAY;IACvB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa;IAUnE;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,QAAQ,CACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,OAAO,EACd,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACrC,aAAa;IAIhB;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,UAAU,CACf,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,EACd,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACrC,eAAe;IAIlB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,OAAO,CACZ,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACrC,YAAY;IAIf;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,SAAS,CACd,MAAM,EAAE,aAAa,EAAE,EACvB,OAAO,EAAE,MAAM,GACd,aAAa;CAYjB"}

package/dist/utils/errorFactory.js

@@ -0,0 +1,116 @@
+import { BeethovnError } from '../base/BeethovnError.js';
+import { ValidationError } from '../domain/DomainError.js';
+import { DatabaseError, NetworkError, UnknownError } from '../infrastructure/InfrastructureError.js';
+/**
+ * Factory for creating typed errors from unknown errors
+ *
+ * Provides consistent error creation patterns and converts
+ * unknown errors into structured BeethovnError instances.
+ */
+export class ErrorFactory {
+    /**
+     * Create appropriate error from unknown error
+     *
+     * @param error - The unknown error to convert
+     * @param context - Optional context string for debugging
+     * @returns Structured BeethovnError instance
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await operation();
+     * } catch (error: unknown) {
+     *   throw ErrorFactory.fromUnknown(error, 'processPayment');
+     * }
+     * ```
+     */
+    static fromUnknown(error, context) {
+        // Already a BeethovnError - return as is
+        if (error instanceof BeethovnError) {
+            return error;
+        }
+        // Any other error type - wrap in UnknownError
+        return new UnknownError(error, context);
+    }
+    /**
+     * Wrap database errors
+     *
+     * @param operation - The database operation that failed
+     * @param error - The original error
+     * @param metadata - Additional context
+     * @returns DatabaseError instance
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await db.query(sql, params);
+     * } catch (error: unknown) {
+     *   throw ErrorFactory.database('saveUser', error, { userId });
+     * }
+     * ```
+     */
+    static database(operation, error, metadata = {}) {
+        return new DatabaseError(operation, error, metadata);
+    }
+    /**
+     * Create validation error with field
+     *
+     * @param message - Error message
+     * @param field - Field that failed validation
+     * @param metadata - Additional context
+     * @returns ValidationError instance
+     *
+     * @example
+     * ```typescript
+     * if (!email.includes('@')) {
+     *   throw ErrorFactory.validation('Invalid email format', 'email');
+     * }
+     * ```
+     */
+    static validation(message, field, metadata = {}) {
+        return new ValidationError(message, field, metadata);
+    }
+    /**
+     * Create network error
+     *
+     * @param message - Error message
+     * @param metadata - Additional context (url, method, etc.)
+     * @returns NetworkError instance
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await fetch(url);
+     * } catch (error: unknown) {
+     *   throw ErrorFactory.network('Failed to fetch data', { url, method: 'GET' });
+     * }
+     * ```
+     */
+    static network(message, metadata = {}) {
+        return new NetworkError(message, metadata);
+    }
+    /**
+     * Convert multiple errors into a single aggregated error
+     *
+     * @param errors - Array of errors to aggregate
+     * @param context - Context for the aggregated error
+     * @returns Single BeethovnError with all errors in metadata
+     *
+     * @example
+     * ```typescript
+     * const errors = validateUser(data);
+     * if (errors.length > 0) {
+     *   throw ErrorFactory.aggregate(errors, 'User validation');
+     * }
+     * ```
+     */
+    static aggregate(errors, context) {
+        const messages = errors.map(e => e.message).join('; ');
+        return new ValidationError(`${context} failed: ${messages}`, undefined, {
+            context,
+            errorCount: errors.length,
+            errors: errors.map(e => e.toJSON()),
+        });
+    }
+}
+//# sourceMappingURL=errorFactory.js.map

package/dist/utils/errorFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorFactory.js","sourceRoot":"","sources":["../../src/utils/errorFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAErG;;;;;GAKG;AACH,MAAM,OAAO,YAAY;IACvB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,WAAW,CAAC,KAAc,EAAE,OAAgB;QACjD,yCAAyC;QACzC,IAAI,KAAK,YAAY,aAAa,EAAE,CAAC;YACnC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,8CAA8C;QAC9C,OAAO,IAAI,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,QAAQ,CACb,SAAiB,EACjB,KAAc,EACd,WAAoC,EAAE;QAEtC,OAAO,IAAI,aAAa,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;IACvD,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,UAAU,CACf,OAAe,EACf,KAAc,EACd,WAAoC,EAAE;QAEtC,OAAO,IAAI,eAAe,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;IACvD,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,OAAO,CACZ,OAAe,EACf,WAAoC,EAAE;QAEtC,OAAO,IAAI,YAAY,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,SAAS,CACd,MAAuB,EACvB,OAAe;QAEf,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvD,OAAO,IAAI,eAAe,CACxB,GAAG,OAAO,YAAY,QAAQ,EAAE,EAChC,SAAS,EACT;YACE,OAAO;YACP,UAAU,EAAE,MAAM,CAAC,MAAM;YACzB,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;SACpC,CACF,CAAC;IACJ,CAAC;CACF"}

package/dist/utils/errorGuards.d.ts

@@ -0,0 +1,133 @@
+import { BeethovnError } from '../base/BeethovnError.js';
+import { DomainError } from '../domain/DomainError.js';
+import { InfrastructureError } from '../infrastructure/InfrastructureError.js';
+import { AuthError } from '../auth/AuthError.js';
+import { IntegrationError } from '../integration/IntegrationError.js';
+/**
+ * Type guards for error classification
+ *
+ * Use these to determine error types in catch blocks and
+ * implement type-safe error handling logic.
+ */
+/**
+ * Check if error is a BeethovnError
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isBeethovnError(error)) {
+ *     logger.error('Beethovn error', error.toJSON());
+ *   }
+ * }
+ * ```
+ */
+export declare function isBeethovnError(error: unknown): error is BeethovnError;
+/**
+ * Check if error is a domain error (business logic)
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isDomainError(error)) {
+ *     // User-fixable error - return helpful message
+ *     return { error: error.toClient() };
+ *   }
+ * }
+ * ```
+ */
+export declare function isDomainError(error: unknown): error is DomainError;
+/**
+ * Check if error is an infrastructure error (technical)
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isInfrastructureError(error)) {
+ *     // Technical error - might be recoverable
+ *     if (error.recoverable) {
+ *       await retry(operation);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare function isInfrastructureError(error: unknown): error is InfrastructureError;
+/**
+ * Check if error is an auth error
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isAuthError(error)) {
+ *     // Auth error - redirect to login or show 401/403
+ *     res.status(error.statusCode).json(error.toClient());
+ *   }
+ * }
+ * ```
+ */
+export declare function isAuthError(error: unknown): error is AuthError;
+/**
+ * Check if error is an integration error
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isIntegrationError(error)) {
+ *     // Integration error - log and maybe retry
+ *     logger.warn('Integration failed', error.toJSON());
+ *   }
+ * }
+ * ```
+ */
+export declare function isIntegrationError(error: unknown): error is IntegrationError;
+/**
+ * Check if error is recoverable (can be retried)
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isRecoverableError(error)) {
+ *     // Retry with exponential backoff
+ *     await retryWithBackoff(operation);
+ *   } else {
+ *     // Non-recoverable - fail fast
+ *     throw error;
+ *   }
+ * }
+ * ```
+ */
+export declare function isRecoverableError(error: unknown): error is BeethovnError;
+/**
+ * Check if error should be exposed to client
+ *
+ * Domain errors are safe to expose, infrastructure errors are not.
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isClientSafeError(error)) {
+ *     res.status(error.statusCode).json(error.toClient());
+ *   } else {
+ *     res.status(500).json({ error: 'Internal server error' });
+ *   }
+ * }
+ * ```
+ */
+export declare function isClientSafeError(error: unknown): error is BeethovnError;
+/**
+ * Get HTTP status code from error
+ *
+ * @param error - Error to get status code from
+ * @param defaultStatus - Default status if error is not a BeethovnError
+ * @returns HTTP status code
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   const statusCode = getErrorStatusCode(error);
+ *   res.status(statusCode).json({ error: 'Something went wrong' });
+ * }
+ * ```
+ */
+export declare function getErrorStatusCode(error: unknown, defaultStatus?: number): number;
+//# sourceMappingURL=errorGuards.d.ts.map

package/dist/utils/errorGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorGuards.d.ts","sourceRoot":"","sources":["../../src/utils/errorGuards.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAC/E,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAEtE;;;;;GAKG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAElE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAElF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAE9D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAE5E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEzE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAExE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,aAAa,GAAE,MAAY,GAAG,MAAM,CAKtF"}

package/dist/utils/errorGuards.js

@@ -0,0 +1,152 @@
+import { BeethovnError } from '../base/BeethovnError.js';
+import { DomainError } from '../domain/DomainError.js';
+import { InfrastructureError } from '../infrastructure/InfrastructureError.js';
+import { AuthError } from '../auth/AuthError.js';
+import { IntegrationError } from '../integration/IntegrationError.js';
+/**
+ * Type guards for error classification
+ *
+ * Use these to determine error types in catch blocks and
+ * implement type-safe error handling logic.
+ */
+/**
+ * Check if error is a BeethovnError
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isBeethovnError(error)) {
+ *     logger.error('Beethovn error', error.toJSON());
+ *   }
+ * }
+ * ```
+ */
+export function isBeethovnError(error) {
+    return error instanceof BeethovnError;
+}
+/**
+ * Check if error is a domain error (business logic)
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isDomainError(error)) {
+ *     // User-fixable error - return helpful message
+ *     return { error: error.toClient() };
+ *   }
+ * }
+ * ```
+ */
+export function isDomainError(error) {
+    return error instanceof DomainError;
+}
+/**
+ * Check if error is an infrastructure error (technical)
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isInfrastructureError(error)) {
+ *     // Technical error - might be recoverable
+ *     if (error.recoverable) {
+ *       await retry(operation);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export function isInfrastructureError(error) {
+    return error instanceof InfrastructureError;
+}
+/**
+ * Check if error is an auth error
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isAuthError(error)) {
+ *     // Auth error - redirect to login or show 401/403
+ *     res.status(error.statusCode).json(error.toClient());
+ *   }
+ * }
+ * ```
+ */
+export function isAuthError(error) {
+    return error instanceof AuthError;
+}
+/**
+ * Check if error is an integration error
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isIntegrationError(error)) {
+ *     // Integration error - log and maybe retry
+ *     logger.warn('Integration failed', error.toJSON());
+ *   }
+ * }
+ * ```
+ */
+export function isIntegrationError(error) {
+    return error instanceof IntegrationError;
+}
+/**
+ * Check if error is recoverable (can be retried)
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isRecoverableError(error)) {
+ *     // Retry with exponential backoff
+ *     await retryWithBackoff(operation);
+ *   } else {
+ *     // Non-recoverable - fail fast
+ *     throw error;
+ *   }
+ * }
+ * ```
+ */
+export function isRecoverableError(error) {
+    return isBeethovnError(error) && error.recoverable;
+}
+/**
+ * Check if error should be exposed to client
+ *
+ * Domain errors are safe to expose, infrastructure errors are not.
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   if (isClientSafeError(error)) {
+ *     res.status(error.statusCode).json(error.toClient());
+ *   } else {
+ *     res.status(500).json({ error: 'Internal server error' });
+ *   }
+ * }
+ * ```
+ */
+export function isClientSafeError(error) {
+    return isDomainError(error) || isAuthError(error);
+}
+/**
+ * Get HTTP status code from error
+ *
+ * @param error - Error to get status code from
+ * @param defaultStatus - Default status if error is not a BeethovnError
+ * @returns HTTP status code
+ *
+ * @example
+ * ```typescript
+ * catch (error: unknown) {
+ *   const statusCode = getErrorStatusCode(error);
+ *   res.status(statusCode).json({ error: 'Something went wrong' });
+ * }
+ * ```
+ */
+export function getErrorStatusCode(error, defaultStatus = 500) {
+    if (isBeethovnError(error)) {
+        return error.statusCode;
+    }
+    return defaultStatus;
+}
+//# sourceMappingURL=errorGuards.js.map

package/dist/utils/errorGuards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorGuards.js","sourceRoot":"","sources":["../../src/utils/errorGuards.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAC/E,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAEtE;;;;;GAKG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAAC,KAAc;IAC5C,OAAO,KAAK,YAAY,aAAa,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc;IAC1C,OAAO,KAAK,YAAY,WAAW,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAc;IAClD,OAAO,KAAK,YAAY,mBAAmB,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,WAAW,CAAC,KAAc;IACxC,OAAO,KAAK,YAAY,SAAS,CAAC;AACpC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,OAAO,KAAK,YAAY,gBAAgB,CAAC;AAC3C,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,OAAO,eAAe,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,WAAW,CAAC;AACrD,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAc;IAC9C,OAAO,aAAa,CAAC,KAAK,CAAC,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAc,EAAE,gBAAwB,GAAG;IAC5E,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC,UAAU,CAAC;IAC1B,CAAC;IACD,OAAO,aAAa,CAAC;AACvB,CAAC"}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@beethovn/errors",
+  "version": "1.0.0",
+  "description": "Standardized error types for the Beethovn platform",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "keywords": [
+    "errors",
+    "error-handling",
+    "typescript",
+    "beethovn"
+  ],
+  "author": "Beethovn Team",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src --ext .ts",
+    "type-check": "tsc --noEmit"
+  }
+}