### Install http-status-codes Package

Source: https://github.com/prettymuchbryce/http-status-codes/wiki/Home

Install the http-status-codes package using npm. This command adds the package as a dependency to your project.

```bash
npm install http-status-codes --save
```

--------------------------------

### Import and Use HTTP Status Codes

Source: https://github.com/prettymuchbryce/http-status-codes/wiki/_Sidebar

Demonstrates importing and utilizing constants and functions from the 'http-status-codes' library. It shows how to set response status to OK and send the reason phrase for OK. It also shows setting the status to INTERNAL_SERVER_ERROR and sending an error object with the corresponding reason phrase.

```javascript
import {
	ReasonPhrases,
	StatusCodes,
	getReasonPhrase,
	getStatusCode,
} from 'http-status-codes';

response
	.status(StatusCodes.OK)
	.send(ReasonPhrases.OK);

response
	.status(StatusCodes.INTERNAL_SERVER_ERROR)
	.send({
		error: getReasonPhrase(StatusCodes.INTERNAL_SERVER_ERROR)
	});

response
	.status(getStatusCode('Internal Server success'))
	.send({
		success: 'Internal Server Success'
	})
```

--------------------------------

### Using getReasonPhrase Function to Log HTTP Responses

Source: https://context7.com/prettymuchbryce/http-status-codes/llms.txt

Shows how to use the getReasonPhrase utility function to convert numeric HTTP status codes into their corresponding human-readable reason phrases. This is useful for logging HTTP requests and responses, and also includes an example of Express middleware.

```typescript
import { getReasonPhrase } from 'http-status-codes';

function logHttpResponse(statusCode: number, url: string) {
  try {
    const phrase = getReasonPhrase(statusCode);
    console.log(`${statusCode} ${phrase} - ${url}`);
  } catch (error) {
    console.error(`Invalid status code: ${statusCode}`);
  }
}

logHttpResponse(200, '/api/users');
// Output: 200 OK - /api/users

logHttpResponse(404, '/api/missing');
// Output: 404 Not Found - /api/missing

logHttpResponse(500, '/api/error');
// Output: 500 Internal Server Error - /api/error

logHttpResponse(9999, '/invalid');
// Output: Invalid status code: 9999

// Express middleware example
app.use((req, res, next) => {
  const originalSend = res.send;
  res.send = function(data) {
    console.log(`Response: ${res.statusCode} ${getReasonPhrase(res.statusCode)}`);
    return originalSend.call(this, data);
  };
  next();
});
```

--------------------------------

### Use Status Codes and Reason Phrases (JavaScript)

Source: https://github.com/prettymuchbryce/http-status-codes/wiki/Home

Demonstrates how to import and use status codes and reason phrases from the http-status-codes package in JavaScript. It shows setting a response status to OK and sending the corresponding reason phrase, as well as handling internal server errors.

```javascript
import {
	ReasonPhrases,
	StatusCodes,
	getReasonPhrase,
	getStatusCode,
} from 'http-status-codes';

response
	.status(StatusCodes.OK)
	.send(ReasonPhrases.OK);

response
	.status(StatusCodes.INTERNAL_SERVER_ERROR)
	.send({
		error: getReasonPhrase(StatusCodes.INTERNAL_SERVER_ERROR)
	});

response
	.status(getStatusCode('Internal Server Error'))
	.send({
		error: 'Internal Server Error'
	});
```

--------------------------------

### Build HTTP Status Codes Package

Source: https://github.com/prettymuchbryce/http-status-codes/blob/master/README.md

Compiles the http-status-codes package for distribution. This step is necessary before publishing.

```shell
npm run build
```

--------------------------------

### Using ReasonPhrases and StatusCodes for API Response Objects

Source: https://context7.com/prettymuchbryce/http-status-codes/llms.txt

Illustrates how to create standardized API response objects using both ReasonPhrases and StatusCodes enums. This function generates a response object including the status code, a human-readable reason phrase, and optional data or error messages.

```typescript
import { ReasonPhrases, StatusCodes } from 'http-status-codes';

function createApiResponse(statusCode: number, data: any = null, error: string = null) {
  const response: any = {
    status: statusCode,
    message: ReasonPhrases[Object.keys(StatusCodes).find(
      key => StatusCodes[key as keyof typeof StatusCodes] === statusCode
    ) as keyof typeof ReasonPhrases]
  };

  if (data) response.data = data;
  if (error) response.error = error;

  return response;
}

const successResponse = createApiResponse(StatusCodes.OK, { id: 123, name: 'John' });
console.log(successResponse);
// Output: { status: 200, message: 'OK', data: { id: 123, name: 'John' } }

const errorResponse = createApiResponse(StatusCodes.UNAUTHORIZED, null, 'Invalid token');
console.log(errorResponse);
// Output: { status: 401, message: 'Unauthorized', error: 'Invalid token' }

const notFoundResponse = createApiResponse(StatusCodes.NOT_FOUND);
console.log(notFoundResponse);
// Output: { status: 404, message: 'Not Found' }
```

--------------------------------

### Test HTTP Status Codes Package

Source: https://github.com/prettymuchbryce/http-status-codes/blob/master/README.md

Runs the test suite for the http-status-codes package to ensure functionality and correctness.

```shell
npm run test
```

--------------------------------

### Manage Package Version and Publish

Source: https://github.com/prettymuchbryce/http-status-codes/blob/master/README.md

Updates the package version (major, minor, or patch) and publishes the new version to the npm registry.

```shell
npm version [major | minor | patch]
npm publish
```

--------------------------------

### Convert Reason Phrase to HTTP Status Code (TypeScript)

Source: https://context7.com/prettymuchbryce/http-status-codes/llms.txt

Demonstrates how to use the `getStatusCode` function from the http-status-codes library to convert a string reason phrase (e.g., 'OK', 'Created') into its corresponding numeric HTTP status code. This function is useful for validating or generating responses based on human-readable status descriptions. It throws an error for unknown phrases.

```typescript
import { getStatusCode } from 'http-status-codes';

function createResponseByPhrase(phrase: string, data: any) {
  try {
    const statusCode = getStatusCode(phrase);
    return {
      statusCode,
      phrase,
      data
    };
  } catch (error) {
    throw new Error(`Unknown reason phrase: ${phrase}`);
  }
}

const okResponse = createResponseByPhrase('OK', { users: [] });
console.log(okResponse);
// Output: { statusCode: 200, phrase: 'OK', data: { users: [] } }

const createdResponse = createResponseByPhrase('Created', { id: 456 });
console.log(createdResponse);
// Output: { statusCode: 201, phrase: 'Created', data: { id: 456 } }

const unauthorizedResponse = createResponseByPhrase('Unauthorized', null);
console.log(unauthorizedResponse);
// Output: { statusCode: 401, phrase: 'Unauthorized', data: null }

try {
  createResponseByPhrase('Invalid Phrase', {});
} catch (error) {
  console.error(error.message);
  // Output: Unknown reason phrase: Invalid Phrase
}
```

--------------------------------

### Express.js RESTful API Integration with HTTP Status Codes (TypeScript)

Source: https://context7.com/prettymuchbryce/http-status-codes/llms.txt

Illustrates a pattern for building RESTful APIs with Express.js, leveraging the http-status-codes library for proper HTTP status code handling and error responses. It includes helper functions for sending success and error responses, and defines standard CRUD endpoints with appropriate status codes for various scenarios.

```typescript
import express from 'express';
import { StatusCodes, getReasonPhrase } from 'http-status-codes';

const app = express();
app.use(express.json());

// Success response helper
function sendSuccess(res: express.Response, statusCode: number, data: any) {
  res.status(statusCode).json({
    success: true,
    status: statusCode,
    message: getReasonPhrase(statusCode),
    data
  });
}

// Error response helper
function sendError(res: express.Response, statusCode: number, message: string) {
  res.status(statusCode).json({
    success: false,
    status: statusCode,
    error: getReasonPhrase(statusCode),
    message
  });
}

// CRUD endpoints
app.get('/api/products', async (req, res) => {
  const products = await database.getAllProducts();
  sendSuccess(res, StatusCodes.OK, products);
});

app.post('/api/products', async (req, res) => {
  if (!req.body.name || !req.body.price) {
    return sendError(res, StatusCodes.BAD_REQUEST, 'Name and price are required');
  }

  const product = await database.createProduct(req.body);
  sendSuccess(res, StatusCodes.CREATED, product);
});

app.put('/api/products/:id', async (req, res) => {
  const product = await database.updateProduct(req.params.id, req.body);

  if (!product) {
    return sendError(res, StatusCodes.NOT_FOUND, 'Product not found');
  }

  sendSuccess(res, StatusCodes.OK, product);
});

app.delete('/api/products/:id', async (req, res) => {
  await database.deleteProduct(req.params.id);
  res.status(StatusCodes.NO_CONTENT).send();
});

// Global error handler
app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
  console.error(err.stack);
  sendError(res, StatusCodes.INTERNAL_SERVER_ERROR, 'An unexpected error occurred');
});

// Output examples:
// GET /api/products => 200 { success: true, status: 200, message: 'OK', data: [...] }
// POST /api/products => 201 { success: true, status: 201, message: 'Created', data: {...} }
// POST /api/products (invalid) => 400 { success: false, status: 400, error: 'Bad Request', message: 'Name and price are required' }
// PUT /api/products/999 => 404 { success: false, status: 404, error: 'Not Found', message: 'Product not found' }
// DELETE /api/products/1 => 204 (no content)

```

--------------------------------

### Using StatusCodes Enum for HTTP Responses in Express

Source: https://context7.com/prettymuchbryce/http-status-codes/llms.txt

Demonstrates how to use the StatusCodes enum from the http-status-codes library to set appropriate HTTP status codes for API endpoints in an Express application. It handles successful responses, not found errors, and internal server errors.

```typescript
import { StatusCodes } from 'http-status-codes';
import express from 'express';

const app = express();

app.get('/api/users/:id', async (req, res) => {
  try {
    const user = await database.findUser(req.params.id);

    if (!user) {
      return res.status(StatusCodes.NOT_FOUND).json({
        error: 'User not found'
      });
    }

    res.status(StatusCodes.OK).json(user);
  } catch (error) {
    res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
      error: 'Database error'
    });
  }
});

app.post('/api/users', async (req, res) => {
  try {
    const newUser = await database.createUser(req.body);
    res.status(StatusCodes.CREATED).json(newUser);
  } catch (error) {
    if (error.code === 'DUPLICATE_EMAIL') {
      return res.status(StatusCodes.CONFLICT).json({
        error: 'Email already exists'
      });
    }
    res.status(StatusCodes.BAD_REQUEST).json({
      error: 'Invalid user data'
    });
  }
});

// Output: 200, 201, 404, 409, 500 depending on the scenario
```

--------------------------------

### Update Status Codes Data

Source: https://github.com/prettymuchbryce/http-status-codes/blob/master/README.md

This command updates the status code data from a JSON file. It is a prerequisite for testing and building the project.

```shell
npm run update-codes
```

--------------------------------

### HTTP Client Error Handling with Status Codes (TypeScript)

Source: https://context7.com/prettymuchbryce/http-status-codes/llms.txt

This TypeScript function 'makeApiRequest' utilizes the 'axios' library and 'http-status-codes' to make API requests and handle responses. It differentiates between successful responses (200, 201, 204) and various client/server errors (4xx, 5xx), returning structured results. Dependencies include 'axios' and 'http-status-codes'.

```typescript
import axios from 'axios';
import { StatusCodes, getReasonPhrase } from 'http-status-codes';

async function makeApiRequest(url: string, options: any = {}) {
  try {
    const response = await axios({
      url,
      method: options.method || 'GET',
      data: options.data,
      headers: options.headers
    });

    switch (response.status) {
      case StatusCodes.OK:
        return { success: true, data: response.data };

      case StatusCodes.CREATED:
        return { success: true, data: response.data, created: true };

      case StatusCodes.NO_CONTENT:
        return { success: true, data: null };

      default:
        return { success: true, data: response.data };
    }
  } catch (error: any) {
    if (error.response) {
      const status = error.response.status;

      switch (status) {
        case StatusCodes.BAD_REQUEST:
          return { success: false, error: 'Invalid request parameters', status };

        case StatusCodes.UNAUTHORIZED:
          return { success: false, error: 'Authentication required', status };

        case StatusCodes.FORBIDDEN:
          return { success: false, error: 'Access denied', status };

        case StatusCodes.NOT_FOUND:
          return { success: false, error: 'Resource not found', status };

        case StatusCodes.TOO_MANY_REQUESTS:
          return { success: false, error: 'Rate limit exceeded', status };

        case StatusCodes.INTERNAL_SERVER_ERROR:
        case StatusCodes.BAD_GATEWAY:
        case StatusCodes.SERVICE_UNAVAILABLE:
          return { success: false, error: 'Server error occurred', status };

        default:
          return {
            success: false,
            error: getReasonPhrase(status),
            status
          };
      }
    }

    return { success: false, error: 'Network error', status: 0 };
  }
}

// Usage examples
const result1 = await makeApiRequest('https://api.example.com/users');
console.log(result1);
// Output: { success: true, data: [...] }

const result2 = await makeApiRequest('https://api.example.com/users', {
  method: 'POST',
  data: { name: 'John' }
});
// Output: { success: true, data: {...}, created: true }

const result3 = await makeApiRequest('https://api.example.com/invalid');
// Output: { success: false, error: 'Resource not found', status: 404 }
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.