@ooneex/exception 0.0.1 → 0.0.5

package/README.md

@@ -1,8 +1,7 @@
 # @ooneex/exception
 
-A comprehensive TypeScript/JavaScript library for creating structured, HTTP status-aware exceptions. This package provides a robust foundation for error handling in web applications with built-in support for HTTP status codes, structured data, and stack trace parsing.
+A type-safe exception handling library with HTTP status code integration for structured error management. This package provides a base `Exception` class and specialized exception types for common HTTP error scenarios with rich metadata including timestamps, status codes, and structured stack traces.
 
-![Browser](https://img.shields.io/badge/Browser-Compatible-green?style=flat-square&logo=googlechrome)
 ![Bun](https://img.shields.io/badge/Bun-Compatible-orange?style=flat-square&logo=bun)
 ![Deno](https://img.shields.io/badge/Deno-Compatible-blue?style=flat-square&logo=deno)
 ![Node.js](https://img.shields.io/badge/Node.js-Compatible-green?style=flat-square&logo=node.js)
@@ -11,21 +10,19 @@ A comprehensive TypeScript/JavaScript library for creating structured, HTTP stat
 
 ## Features
 
-✅ **HTTP Status Integration** - Built-in support for HTTP status codes via @ooneex/http-status
+✅ **HTTP Status Integration** - Built-in support for all HTTP status codes
 
-✅ **Type-Safe** - Full TypeScript support with generic data types
+✅ **Structured Stack Traces** - Parse stack traces into JSON for logging and debugging
 
-✅ **Structured Data** - Attach custom data objects to exceptions
+✅ **Rich Metadata** - Include timestamps, custom data, and original errors
 
-✅ **Stack Trace Parsing** - Parse stack traces into structured JSON format
+✅ **Specialized Exceptions** - Pre-built exceptions for common HTTP errors
 
-✅ **Predefined Exceptions** - Common HTTP exceptions (400, 401, 404, 405)
+✅ **Type-Safe** - Full TypeScript support with proper type definitions
 
-✅ **Cross-Platform** - Works in Browser, Node.js, Bun, and Deno
+✅ **Immutable Data** - Exception data is frozen after creation
 
-✅ **Immutable Data** - Exception data is automatically frozen
-
-✅ **Error Wrapping** - Wrap native Error objects with additional context
+✅ **Native Error Wrapping** - Wrap native JavaScript errors while preserving context
 
 ## Installation
 
@@ -51,290 +48,213 @@ npm install @ooneex/exception
 
 ## Usage
 
-### Basic Usage
+### Basic Exception
+
+```typescript
+import { Exception } from '@ooneex/exception';
+
+throw new Exception('Something went wrong');
+```
+
+### With HTTP Status Code
 
 ```typescript
 import { Exception } from '@ooneex/exception';
+import { HttpStatus } from '@ooneex/http-status';
+
+throw new Exception('Resource not found', {
+  status: HttpStatus.Code.NotFound
+});
+```
 
-// Simple exception with message
-const exception = new Exception('Something went wrong');
+### With Custom Data
 
-console.log(exception.message); // "Something went wrong"
-console.log(exception.name); // "Exception"
-console.log(exception.date); // Date object
+```typescript
+import { Exception } from '@ooneex/exception';
 
-// Exception with HTTP status and data
-const detailedException = new Exception('User not found', {
-  status: 404,
+throw new Exception('Validation failed', {
+  status: 400,
   data: {
-    userId: 123,
-    searchCriteria: { email: 'user@example.com' }
+    field: 'email',
+    value: 'invalid-email',
+    constraint: 'Must be a valid email address'
   }
 });
-
-console.log(detailedException.status); // 404
-console.log(detailedException.data); // { userId: 123, searchCriteria: {...} }
 ```
 
-### Using Predefined Exceptions
+### Specialized Exceptions
 
 ```typescript
 import {
+  NotFoundException,
   BadRequestException,
   UnauthorizedException,
-  NotFoundException,
   MethodNotAllowedException
 } from '@ooneex/exception';
 
-// 400 Bad Request
-throw new BadRequestException('Invalid input data', {
-  field: 'email',
-  value: 'invalid-email',
-  rule: 'Must be a valid email address'
+// 404 Not Found
+throw new NotFoundException('User not found', {
+  data: { userId: '123' }
 });
 
-// 401 Unauthorized
-throw new UnauthorizedException('Token expired', {
-  token: 'eyJ...',
-  expiredAt: new Date()
+// 400 Bad Request
+throw new BadRequestException('Invalid input', {
+  data: { errors: ['email is required', 'name is too short'] }
 });
 
-// 404 Not Found
-throw new NotFoundException('Resource not found', {
-  resourceType: 'User',
-  id: 123
-});
+// 401 Unauthorized
+throw new UnauthorizedException('Invalid credentials');
 
 // 405 Method Not Allowed
-throw new MethodNotAllowedException('POST not allowed on this endpoint', {
-  method: 'POST',
-  allowedMethods: ['GET', 'PUT']
-});
+throw new MethodNotAllowedException('POST method not allowed on this endpoint');
 ```
 
-### Error Wrapping
+### Wrapping Native Errors
 
 ```typescript
 import { Exception } from '@ooneex/exception';
 
 try {
-  // Some operation that might fail
   JSON.parse('invalid json');
 } catch (error) {
-  // Wrap the native error with additional context
   throw new Exception(error as Error, {
-    status: 400,
-    data: {
-      operation: 'JSON parsing',
-      input: 'invalid json'
-    }
+    status: 500,
+    data: { context: 'Parsing configuration file' }
   });
 }
 ```
 
-### Stack Trace Parsing
+### Accessing Stack Trace as JSON
 
 ```typescript
 import { Exception } from '@ooneex/exception';
 
-const exception = new Exception('Parsing failed');
-const stackFrames = exception.stackToJson();
-
-console.log(stackFrames);
-// [
-//   {
-//     functionName: 'parseData',
-//     fileName: '/path/to/file.ts',
-//     lineNumber: 42,
-//     columnNumber: 15,
-//     source: '    at parseData (/path/to/file.ts:42:15)'
-//   },
-//   ...
-// ]
-```
-
-### Generic Data Types
-
-```typescript
-import { Exception } from '@ooneex/exception';
-
-// Define custom data interface
-interface ValidationError {
-  field: string;
-  value: unknown;
-  rule: string;
-  message: string;
-}
-
-// Create typed exception
-const validationException = new Exception<ValidationError>('Validation failed', {
-  status: 400,
-  data: {
-    field: 'email',
-    value: 'not-an-email',
-    rule: 'email',
-    message: 'Must be a valid email address'
+try {
+  throw new Exception('Test error');
+} catch (error) {
+  if (error instanceof Exception) {
+    const stackFrames = error.stackToJson();
+    
+    stackFrames?.forEach((frame, index) => {
+      console.log(`${index + 1}. ${frame.functionName || '<anonymous>'}`);
+      console.log(`   at ${frame.fileName}:${frame.lineNumber}:${frame.columnNumber}`);
+    });
   }
-});
-
-// TypeScript ensures type safety
-console.log(validationException.data?.field); // string
-console.log(validationException.data?.rule); // string
+}
 ```
 
 ## API Reference
 
-### `Exception<T>` Class
+### Classes
 
-The main exception class providing structured error handling with optional HTTP status and custom data.
+#### `Exception`
 
-#### Constructor
+Base exception class that extends the native `Error` with additional metadata.
 
+**Constructor:**
 ```typescript
-new Exception<T>(message: string | Error, options?: {
-  status?: StatusCodeType;
-  data?: T;
-})
+new Exception(
+  message: string | Error,
+  options?: {
+    status?: StatusCodeType;
+    data?: Record<string, unknown>;
+  }
+)
 ```
 
 **Parameters:**
 - `message` - Error message string or native Error object to wrap
-- `options.status` - HTTP status code (from @ooneex/http-status)
-- `options.data` - Custom data object (automatically frozen)
-
-#### Properties
+- `options.status` - HTTP status code (default: 500)
+- `options.data` - Additional contextual data
 
-##### `date: Date` (readonly)
-Timestamp when the exception was created.
+**Properties:**
 
-```typescript
-const exception = new Exception('Error occurred');
-console.log(exception.date); // 2024-01-15T10:30:00.000Z
-```
-
-##### `status?: StatusCodeType` (readonly)
-HTTP status code associated with the exception.
-
-```typescript
-const exception = new Exception('Not found', { status: 404 });
-console.log(exception.status); // 404
-```
-
-##### `data?: T` (readonly)
-Custom data object associated with the exception. Automatically frozen to prevent mutations.
+| Property | Type | Description |
+|----------|------|-------------|
+| `date` | `Date` | Timestamp when the exception was created |
+| `status` | `StatusCodeType` | HTTP status code |
+| `data` | `Readonly<Record<string, unknown>>` | Immutable custom data |
+| `native` | `Error \| undefined` | Original Error if wrapping a native error |
+| `message` | `string` | Error message |
+| `name` | `string` | Exception class name |
+| `stack` | `string \| undefined` | Stack trace string |
 
-```typescript
-const exception = new Exception('Error', {
-  data: { userId: 123, action: 'delete' }
-});
-console.log(exception.data); // { userId: 123, action: 'delete' }
-// exception.data.userId = 456; // TypeError: Cannot assign to read only property
-```
-
-##### `native?: Error` (readonly)
-Original native Error object when wrapping existing errors.
-
-```typescript
-const originalError = new Error('Original message');
-const exception = new Exception(originalError);
-console.log(exception.native); // Original Error object
-```
-
-##### `message: string`
-Error message (inherited from Error).
-
-##### `name: string`
-Exception name (inherited from Error).
-
-##### `stack?: string`
-Stack trace string (inherited from Error).
-
-#### Methods
+**Methods:**
 
 ##### `stackToJson(): ExceptionStackFrameType[] | null`
-Parses the stack trace into a structured JSON format.
 
-**Returns:** Array of stack frame objects or `null` if no stack trace available.
+Converts the stack trace into a structured JSON array.
+
+**Returns:** Array of stack frames or null if no stack trace is available
 
 **Example:**
 ```typescript
-const exception = new Exception('Error occurred');
+const exception = new Exception('Test error');
 const frames = exception.stackToJson();
 
-if (frames) {
-  frames.forEach(frame => {
-    console.log(`Function: ${frame.functionName}`);
-    console.log(`File: ${frame.fileName}:${frame.lineNumber}:${frame.columnNumber}`);
-    console.log(`Source: ${frame.source}`);
-  });
-}
+console.log(frames);
+// [
+//   {
+//     functionName: 'myFunction',
+//     fileName: '/path/to/file.ts',
+//     lineNumber: 42,
+//     columnNumber: 15,
+//     source: '    at myFunction (/path/to/file.ts:42:15)'
+//   },
+//   ...
+// ]
 ```
 
-### Predefined Exception Classes
+#### `BadRequestException`
 
-#### `BadRequestException<T>`
-HTTP 400 Bad Request exception.
+Exception for 400 Bad Request errors.
 
 ```typescript
-new BadRequestException<T>(message: string, data?: T)
+new BadRequestException(message: string, options?: { data?: Record<string, unknown> })
 ```
 
-**Example:**
-```typescript
-throw new BadRequestException('Invalid request data', {
-  validationErrors: ['email is required', 'age must be a number']
-});
-```
+#### `NotFoundException`
 
-#### `UnauthorizedException<T>`
-HTTP 401 Unauthorized exception.
+Exception for 404 Not Found errors.
 
 ```typescript
-new UnauthorizedException<T>(message: string, data?: T)
+new NotFoundException(message: string, options?: { data?: Record<string, unknown> })
 ```
 
-**Example:**
-```typescript
-throw new UnauthorizedException('Access token expired', {
-  tokenType: 'Bearer',
-  expiredAt: new Date()
-});
-```
+#### `UnauthorizedException`
 
-#### `NotFoundException<T>`
-HTTP 404 Not Found exception.
+Exception for 401 Unauthorized errors.
 
 ```typescript
-new NotFoundException<T>(message: string, data?: T)
+new UnauthorizedException(message: string, options?: { data?: Record<string, unknown> })
 ```
 
-**Example:**
-```typescript
-throw new NotFoundException('User not found', {
-  userId: 123,
-  searchedBy: 'email'
-});
-```
+#### `MethodNotAllowedException`
 
-#### `MethodNotAllowedException<T>`
-HTTP 405 Method Not Allowed exception.
+Exception for 405 Method Not Allowed errors.
 
 ```typescript
-new MethodNotAllowedException<T>(message: string, data?: T)
+new MethodNotAllowedException(message: string, options?: { data?: Record<string, unknown> })
 ```
 
-**Example:**
+### Types
+
+#### `IException`
+
 ```typescript
-throw new MethodNotAllowedException('DELETE method not allowed', {
-  requestedMethod: 'DELETE',
-  allowedMethods: ['GET', 'POST', 'PUT']
-});
+interface IException {
+  readonly date: Date;
+  readonly status: StatusCodeType;
+  readonly data: Readonly<Record<string, unknown>>;
+  readonly native?: Error;
+  readonly message: string;
+  readonly name: string;
+  readonly stack?: string;
+  stackToJson: () => ExceptionStackFrameType[] | null;
+}
 ```
 
-### Types and Interfaces
-
 #### `ExceptionStackFrameType`
-Represents a single frame in a parsed stack trace.
 
 ```typescript
 type ExceptionStackFrameType = {
@@ -346,112 +266,103 @@ type ExceptionStackFrameType = {
 };
 ```
 
-#### `IException<T>`
-Interface defining the exception contract.
-
-```typescript
-interface IException<T = unknown> {
-  readonly date: Date;
-  readonly status?: StatusCodeType;
-  readonly data?: Readonly<Record<string, T>>;
-  readonly native?: Error;
-  readonly message: string;
-  readonly name: string;
-  readonly stack?: string;
-  stackToJson(): ExceptionStackFrameType[] | null;
-}
-```
-
 ## Advanced Usage
 
-### Custom Exception Classes
+### Creating Custom Exceptions
 
 ```typescript
 import { Exception } from '@ooneex/exception';
 import { HttpStatus } from '@ooneex/http-status';
 
-class PaymentException extends Exception {
-  constructor(message: string, data: Record<string, unknown> = {}) {
+class ValidationException extends Exception {
+  constructor(
+    message: string,
+    public readonly errors: string[]
+  ) {
     super(message, {
-      status: HttpStatus.Code.PaymentRequired, // 402
-      data
+      status: HttpStatus.Code.BadRequest,
+      data: { errors }
     });
+    this.name = 'ValidationException';
   }
 }
 
-// Usage
-throw new PaymentException('Insufficient funds', {
-  accountBalance: 50.00,
-  requiredAmount: 100.00,
-  currency: 'USD'
-});
+throw new ValidationException('Validation failed', [
+  'Email is required',
+  'Password must be at least 8 characters'
+]);
 ```
 
-### Error Serialization
+### Error Handling in Controllers
 
 ```typescript
-import { Exception } from '@ooneex/exception';
-
-const exception = new Exception('Process failed', {
-  status: 500,
-  data: {
-    processId: 'proc-123',
-    step: 'validation',
-    retryCount: 3
+import { Exception, NotFoundException, BadRequestException } from '@ooneex/exception';
+import type { IController, ContextType } from '@ooneex/controller';
+
+class UserController implements IController {
+  public async index(context: ContextType) {
+    try {
+      const user = await this.findUser(context.params.id);
+      return context.response.json({ user });
+    } catch (error) {
+      if (error instanceof NotFoundException) {
+        return context.response.notFound(error.message, {
+          data: error.data
+        });
+      }
+      
+      if (error instanceof Exception) {
+        return context.response.exception(error.message, {
+          status: error.status,
+          data: error.data
+        });
+      }
+      
+      throw error;
+    }
   }
-});
-
-// Serialize for logging or API responses
-const serialized = JSON.stringify({
-  message: exception.message,
-  name: exception.name,
-  status: exception.status,
-  data: exception.data,
-  date: exception.date,
-  stackFrames: exception.stackToJson()
-});
-
-console.log(serialized);
+}
 ```
 
-### Integration with Express.js
+### Logging Exceptions
 
 ```typescript
-import express from 'express';
-import { Exception, NotFoundException } from '@ooneex/exception';
-
-const app = express();
+import { Exception } from '@ooneex/exception';
+import { TerminalLogger } from '@ooneex/logger';
 
-app.get('/users/:id', (req, res, next) => {
-  const userId = req.params.id;
+const logger = new TerminalLogger();
 
-  // Simulate user lookup
-  const user = findUser(userId);
-  if (!user) {
-    throw new NotFoundException('User not found', {
-      userId,
-      searchedBy: 'id'
-    });
+try {
+  // Some operation that might fail
+  throw new Exception('Database connection failed', {
+    status: 500,
+    data: { host: 'localhost', port: 5432 }
+  });
+} catch (error) {
+  if (error instanceof Exception) {
+    logger.error(error);
   }
+}
+```
 
-  res.json(user);
-});
+### Serializing Exceptions for API Responses
 
-// Error handler
-app.use((error: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
-  if (error instanceof Exception) {
-    res.status(error.status || 500).json({
-      error: {
-        message: error.message,
-        status: error.status,
-        data: error.data,
-        timestamp: error.date
-      }
-    });
-  } else {
-    next(error);
-  }
-});
+```typescript
+import { Exception } from '@ooneex/exception';
+
+function serializeException(exception: Exception) {
+  return {
+    error: {
+      message: exception.message,
+      status: exception.status,
+      timestamp: exception.date.toISOString(),
+      data: exception.data,
+      stack: process.env.NODE_ENV !== 'production' 
+        ? exception.stackToJson() 
+        : undefined
+    }
+  };
+}
 ```
 
 ## License

package/dist/index.js

@@ -1,4 +1,4 @@
-import{HttpStatus as w}from"@ooneex/http-status";class p extends Error{date=new Date;status;data;native;constructor(r,t){super(r instanceof Error?r.message:r);if(this.status=t?.status||500,this.data=t?.data||{},r instanceof Error)this.native=r;this.name=this.constructor.name,this.data=Object.freeze(this.data)}stackToJson(){if(!this.stack)return null;let r=this.stack.split(`
-`),t=[];for(let u=1;u<r.length;u++){let E=r[u]?.trim();if(!E)continue;let o={source:E},R=E.match(/^\s*at\s+(.+)$/);if(R){let x=R[1],y=x?.match(/^(.+?)\s+\((.+)\)$/);if(y){let e=y[1],n=y[2];if(e)o.functionName=e;let d=n?.match(/^(.+):(\d+):(\d+)$/);if(d){let s=d[1],S=d[2],k=d[3];if(s)o.fileName=s;if(S)o.lineNumber=Number.parseInt(S,10);if(k)o.columnNumber=Number.parseInt(k,10)}else if(n)o.fileName=n}else{let e=x?.match(/^(.+):(\d+):(\d+)$/);if(e){let n=e[1],d=e[2],s=e[3];if(n)o.fileName=n;if(d)o.lineNumber=Number.parseInt(d,10);if(s)o.columnNumber=Number.parseInt(s,10)}else if(x)o.functionName=x}}t.push(o)}return t}}class g extends p{constructor(r,t={}){super(r,{status:w.Code.BadRequest,data:t});this.name="BadRequestException"}}import{HttpStatus as C}from"@ooneex/http-status";class F extends p{constructor(r,t={}){super(r,{status:C.Code.MethodNotAllowed,data:t});this.name="MethodNotAllowedException"}}import{HttpStatus as T}from"@ooneex/http-status";class H extends p{constructor(r,t={}){super(r,{status:T.Code.NotFound,data:t});this.name="NotFoundException"}}import{HttpStatus as b}from"@ooneex/http-status";class i extends p{constructor(r,t={}){super(r,{status:b.Code.Unauthorized,data:t});this.name="UnauthorizedException"}}export{i as UnauthorizedException,H as NotFoundException,F as MethodNotAllowedException,p as Exception,g as BadRequestException};
+import{HttpStatus as F}from"@ooneex/http-status";class p extends Error{date=new Date;status;data;native;constructor(t,r){super(t instanceof Error?t.message:t);if(this.status=r?.status||500,this.data=r?.data||{},t instanceof Error)this.native=t;this.name=this.constructor.name,this.data=Object.freeze(this.data)}stackToJson(){if(!this.stack)return null;let t=this.stack.split(`
+`),r=[];for(let u=1;u<t.length;u++){let E=t[u]?.trim();if(!E)continue;let o={source:E},R=E.match(/^\s*at\s+(.+)$/);if(R){let s=R[1],y=s?.match(/^(.+?)\s+\((.+)\)$/);if(y){let e=y[1],d=y[2];if(e)o.functionName=e;let n=d?.match(/^(.+):(\d+):(\d+)$/);if(n){let x=n[1],i=n[2],w=n[3];if(x)o.fileName=x;if(i)o.lineNumber=Number.parseInt(i,10);if(w)o.columnNumber=Number.parseInt(w,10)}else if(d)o.fileName=d}else{let e=s?.match(/^(.+):(\d+):(\d+)$/);if(e){let d=e[1],n=e[2],x=e[3];if(d)o.fileName=d;if(n)o.lineNumber=Number.parseInt(n,10);if(x)o.columnNumber=Number.parseInt(x,10)}else if(s)o.functionName=s}}r.push(o)}return r}}class S extends p{constructor(t,r={}){super(t,{status:F.Code.BadRequest,data:r});this.name="BadRequestException"}}import{HttpStatus as T}from"@ooneex/http-status";class k extends p{constructor(t,r={}){super(t,{status:T.Code.MethodNotAllowed,data:r});this.name="MethodNotAllowedException"}}import{HttpStatus as q}from"@ooneex/http-status";class g extends p{constructor(t,r={}){super(t,{status:q.Code.NotFound,data:r});this.name="NotFoundException"}}import{HttpStatus as z}from"@ooneex/http-status";class C extends p{constructor(t,r={}){super(t,{status:z.Code.Unauthorized,data:r});this.name="UnauthorizedException"}}export{C as UnauthorizedException,g as NotFoundException,k as MethodNotAllowedException,p as Exception,S as BadRequestException};
 
-//# debugId=C86D27C94A89C34764756E2164756E21
+//# debugId=70B57CA4AB9AB8CA64756E2164756E21

package/dist/index.js.map

@@ -9,6 +9,6 @@
     "import { HttpStatus } from \"@ooneex/http-status\";\nimport { Exception } from \"./Exception\";\n\nexport class UnauthorizedException extends Exception {\n  constructor(message: string, data: Record<string, unknown> = {}) {\n    super(message, {\n      status: HttpStatus.Code.Unauthorized,\n      data,\n    });\n    this.name = \"UnauthorizedException\";\n  }\n}\n"
   ],
   "mappings": "AAAA,qBAAS,4BCGF,MAAM,UAAkB,KAA4B,CACzC,KAAa,IAAI,KACjB,OACA,KACA,OAEhB,WAAW,CAAC,EAAyB,EAAuE,CAC1G,MAAM,aAAmB,MAAS,EAAkB,QAAU,CAAO,EAKrE,GAHA,KAAK,OAAS,GAAS,QAAU,IACjC,KAAK,KAAO,GAAS,MAAQ,CAAC,EAE1B,aAAmB,MACrB,KAAK,OAAS,EAEhB,KAAK,KAAO,KAAK,YAAY,KAC7B,KAAK,KAAO,OAAO,OAAO,KAAK,IAAI,EAO9B,WAAW,EAAqC,CACrD,GAAI,CAAC,KAAK,MACR,OAAO,KAGT,IAAM,EAAa,KAAK,MAAM,MAAM;AAAA,CAAI,EAClC,EAAoC,CAAC,EAG3C,QAAS,EAAI,EAAG,EAAI,EAAW,OAAQ,IAAK,CAC1C,IAAM,EAAO,EAAW,IAAI,KAAK,EACjC,GAAI,CAAC,EAAM,SAEX,IAAM,EAAiC,CACrC,OAAQ,CACV,EAOM,EAAU,EAAK,MAAM,gBAAgB,EAC3C,GAAI,EAAS,CACX,IAAM,EAAU,EAAQ,GAGlB,EAAwB,GAAS,MAAM,oBAAoB,EACjE,GAAI,EAAuB,CACzB,IAAM,EAAe,EAAsB,GACrC,EAAW,EAAsB,GAEvC,GAAI,EACF,EAAM,aAAe,EAIvB,IAAM,EAAgB,GAAU,MAAM,oBAAoB,EAC1D,GAAI,EAAe,CACjB,IAAM,EAAW,EAAc,GACzB,EAAU,EAAc,GACxB,EAAS,EAAc,GAE7B,GAAI,EACF,EAAM,SAAW,EAEnB,GAAI,EACF,EAAM,WAAa,OAAO,SAAS,EAAS,EAAE,EAEhD,GAAI,EACF,EAAM,aAAe,OAAO,SAAS,EAAQ,EAAE,EAE5C,QAAI,EACT,EAAM,SAAW,EAEd,KAEL,IAAM,EAAsB,GAAS,MAAM,oBAAoB,EAC/D,GAAI,EAAqB,CACvB,IAAM,EAAW,EAAoB,GAC/B,EAAU,EAAoB,GAC9B,EAAS,EAAoB,GAEnC,GAAI,EACF,EAAM,SAAW,EAEnB,GAAI,EACF,EAAM,WAAa,OAAO,SAAS,EAAS,EAAE,EAEhD,GAAI,EACF,EAAM,aAAe,OAAO,SAAS,EAAQ,EAAE,EAE5C,QAAI,EAET,EAAM,aAAe,GAK3B,EAAO,KAAK,CAAK,EAGnB,OAAO,EAEX,CD3GO,MAAM,UAA4B,CAAU,CACjD,WAAW,CAAC,EAAiB,EAAgC,CAAC,EAAG,CAC/D,MAAM,EAAS,CACb,OAAQ,EAAW,KAAK,WACxB,MACF,CAAC,EACD,KAAK,KAAO,sBAEhB,CEXA,qBAAS,4BAGF,MAAM,UAAkC,CAAU,CACvD,WAAW,CAAC,EAAiB,EAAgC,CAAC,EAAG,CAC/D,MAAM,EAAS,CACb,OAAQ,EAAW,KAAK,iBACxB,MACF,CAAC,EACD,KAAK,KAAO,4BAEhB,CCXA,qBAAS,4BAGF,MAAM,UAA0B,CAAU,CAC/C,WAAW,CAAC,EAAiB,EAAgC,CAAC,EAAG,CAC/D,MAAM,EAAS,CACb,OAAQ,EAAW,KAAK,SACxB,MACF,CAAC,EACD,KAAK,KAAO,oBAEhB,CCXA,qBAAS,4BAGF,MAAM,UAA8B,CAAU,CACnD,WAAW,CAAC,EAAiB,EAAgC,CAAC,EAAG,CAC/D,MAAM,EAAS,CACb,OAAQ,EAAW,KAAK,aACxB,MACF,CAAC,EACD,KAAK,KAAO,wBAEhB",
-  "debugId": "C86D27C94A89C34764756E2164756E21",
+  "debugId": "70B57CA4AB9AB8CA64756E2164756E21",
   "names": []
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ooneex/exception",
-  "description": "",
-  "version": "0.0.1",
+  "description": "Type-safe exception handling with HTTP status code integration for structured error management",
+  "version": "0.0.5",
   "type": "module",
   "files": [
     "dist",
@@ -25,13 +25,18 @@
     "test": "bun test tests",
     "build": "bunup",
     "lint": "tsgo --noEmit && bunx biome lint",
-    "publish:prod": "bun publish --tolerate-republish --access public",
-    "publish:pack": "bun pm pack --destination ./dist",
-    "publish:dry": "bun publish --dry-run"
+    "npm:publish": "bun publish --tolerate-republish --access public"
   },
   "dependencies": {
     "@ooneex/http-status": "0.0.1"
   },
   "devDependencies": {},
-  "peerDependencies": {}
+  "keywords": [
+    "bun",
+    "error",
+    "error-handling",
+    "exception",
+    "ooneex",
+    "typescript"
+  ]
 }