ts-packages 1.0.0

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "ts-packages",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.20.0",
+  "devDependencies": {
+    "eslint": "^9.39.1",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.3"
+  }
+}

package/packages/response-utils/README.md

@@ -0,0 +1,110 @@
+# @naman_deep_singh/response-utils
+
+TypeScript utilities for standardized HTTP API responses with common status codes and error handling. Supports both standalone usage and Express.js integration.
+
+## Installation
+
+```bash
+npm install @naman_deep_singh/response-utils
+```
+
+## Features
+
+- ✅ **Standardized API responses** with consistent format
+- ✅ **Express.js integration** - automatically sets HTTP status codes
+- ✅ **TypeScript support** with full type safety
+- ✅ **Hybrid exports** - use named imports or namespace imports
+- ✅ **Pagination support** with metadata
+- ✅ **Common HTTP status codes** (200, 201, 400, 401, 403, 404, 408, 409, 422, 429, 500)
+
+## Usage
+
+### Named Imports (Tree-shakable)
+```typescript
+import { success, error, created, notFound, paginated } from '@naman_deep_singh/response-utils';
+
+// Success responses
+const userResponse = success({ id: 1, name: 'John' }, 'User found');
+const createdResponse = created({ id: 2, name: 'Jane' });
+
+// Error responses
+const errorResponse = notFound('User not found');
+const validationResponse = validationError('Invalid input', ['Name is required']);
+
+// Paginated responses
+const paginatedUsers = paginated([{id: 1}, {id: 2}], 1, 10, 25);
+```
+
+### Namespace Import
+```typescript
+import ResponseUtils from '@naman_deep_singh/response-utils';
+
+const response = ResponseUtils.success({ id: 1 }, 'Success');
+```
+
+### Express.js Integration
+```typescript
+import { success, notFound } from '@naman_deep_singh/response-utils';
+import { Request, Response } from 'express';
+
+app.get('/users/:id', (req: Request, res: Response) => {
+  const user = findUser(req.params.id);
+  
+  if (!user) {
+    return notFound('User not found', res); // Sets status 404 and sends response
+  }
+  
+  return success(user, 'User found', 200, res); // Sets status 200 and sends response
+});
+```
+
+## API Reference
+
+### Success Responses
+- `success<T>(data: T, message?, statusCode?, res?)` - Generic success response (200)
+- `created<T>(data: T, message?, res?)` - 201 Created response
+- `noContent(message?, res?)` - 204 No Content response
+- `paginated<T>(data: T[], page, limit, total, message?, res?)` - Paginated response with metadata
+
+### Error Responses
+- `error(message, statusCode?, error?, res?)` - Generic error response
+- `badRequest(message?, validationError?, res?)` - 400 Bad Request
+- `unauthorized(message?, res?)` - 401 Unauthorized
+- `forbidden(message?, res?)` - 403 Forbidden
+- `notFound(message?, res?)` - 404 Not Found
+- `timeout(message?, res?)` - 408 Request Timeout
+- `conflict(message?, res?)` - 409 Conflict
+- `validationError(message?, errors[], res?)` - 422 Validation Error
+- `tooManyRequests(message?, res?)` - 429 Too Many Requests
+- `serverError(message?, res?)` - 500 Internal Server Error
+
+### Utility Functions
+- `logError(context: string, error: unknown)` - Structured error logging
+- `getErrorMessage(error: unknown)` - Extract error message safely
+
+## Response Format
+
+All responses follow the `ApiResponse<T>` interface:
+
+```typescript
+interface ApiResponse<T = any> {
+  success: boolean;
+  message: string;
+  data?: T;
+  error?: string;
+  statusCode: number;
+}
+```
+
+## Paginated Response Format
+
+```typescript
+interface PaginatedResponse<T> extends ApiResponse<T[]> {
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+  };
+}
+```

package/packages/response-utils/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@naman_deep_singh/response-utils",
+  "version": "1.0.7",
+  "description": "TypeScript utilities for standardized HTTP API responses with common status codes and error handling",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "response",
+    "http",
+    "api",
+    "utils"
+  ],
+  "author": "Naman Deep Singh",
+  "license": "ISC",
+  "packageManager": "pnpm@10.20.0",
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/packages/response-utils/src/index.ts

@@ -0,0 +1,168 @@
+export interface ApiResponse<T = any> {
+  success: boolean;
+  message: string;
+  data?: T;
+  error?: string;
+  statusCode: number;
+}
+
+export interface ResponseObject {
+  status: (code: number) => ResponseObject;
+  json: (data: unknown) => any;
+}
+
+export const success = <T>(data: T, message = 'Success', statusCode = 200, res?: ResponseObject): ApiResponse<T> => {
+  const response = {
+    success: true,
+    message,
+    data,
+    statusCode
+  };
+  
+  if (res) {
+    return res.status(statusCode).json(response);
+  }
+  
+  return response;
+};
+
+export const error = (message: string, statusCode = 500, error?: string, res?: ResponseObject): ApiResponse => {
+  const response = {
+    success: false,
+    message,
+    error,
+    statusCode
+  };
+  
+  if (res) {
+    return res.status(statusCode).json(response);
+  }
+  
+  return response;
+};
+
+export const created = <T>(data: T, message = 'Created successfully', res?: ResponseObject): ApiResponse<T> =>
+  success(data, message, 201, res);
+
+export const notFound = (message = 'Resource not found', res?: ResponseObject): ApiResponse =>
+  error(message, 404, undefined, res);
+
+export const badRequest = (message = 'Bad request', validationError?: string, res?: ResponseObject): ApiResponse =>
+  error(message, 400, validationError, res);
+
+export const unauthorized = (message = 'Unauthorized', res?: ResponseObject): ApiResponse =>
+  error(message, 401, undefined, res);
+
+export const forbidden = (message = 'Forbidden', res?: ResponseObject): ApiResponse =>
+  error(message, 403, undefined, res);
+
+export const serverError = (message = 'Internal server error', res?: ResponseObject): ApiResponse =>
+  error(message, 500, undefined, res);
+
+export const noContent = (message = 'No content', res?: ResponseObject): ApiResponse => {
+  const response = {
+    success: true,
+    message,
+    statusCode: 204
+  };
+  
+  if (res) {
+    return res.status(204).json(response);
+  }
+  
+  return response;
+};
+
+export const conflict = (message = 'Conflict', res?: ResponseObject): ApiResponse =>
+  error(message, 409, undefined, res);
+
+export const validationError = (message = 'Validation failed', errors: string[], res?: ResponseObject): ApiResponse => {
+  const response = {
+    success: false,
+    message,
+    error: errors.join(', '),
+    statusCode: 422
+  };
+  
+  if (res) {
+    return res.status(422).json(response);
+  }
+  
+  return response;
+};
+
+export interface PaginatedResponse<T> extends ApiResponse<T[]> {
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+  };
+}
+
+export const paginated = <T>(
+  data: T[],
+  page: number,
+  limit: number,
+  total: number,
+  message = 'Data retrieved successfully',
+  res?: ResponseObject
+): PaginatedResponse<T> => {
+  const response = {
+    success: true,
+    message,
+    data,
+    statusCode: 200,
+    pagination: {
+      page,
+      limit,
+      total,
+      totalPages: Math.ceil(total / limit)
+    }
+  };
+  
+  if (res) {
+    return res.status(200).json(response);
+  }
+  
+  return response;
+};
+
+export const tooManyRequests = (message = 'Too many requests', res?: ResponseObject): ApiResponse => 
+  error(message, 429, undefined, res);
+
+export const timeout = (message = 'Request timeout', res?: ResponseObject): ApiResponse => 
+  error(message, 408, undefined, res);
+
+export const logError = (context: string, error: unknown): void => {
+  const message = error instanceof Error ? error.message : 'Unknown error';
+  console.error(`Error in ${context}:`, message);
+};
+
+export const getErrorMessage = (error: unknown): string => {
+  if (error instanceof Error) return error.message;
+  if (typeof error === 'string') return error;
+  return 'An unknown error occurred';
+};
+
+// Default export for namespace usage
+const ResponseUtils = {
+  success,
+  error,
+  created,
+  notFound,
+  badRequest,
+  unauthorized,
+  forbidden,
+  serverError,
+  noContent,
+  conflict,
+  validationError,
+  paginated,
+  tooManyRequests,
+  timeout,
+  logError,
+  getErrorMessage
+};
+
+export default ResponseUtils;

package/packages/response-utils/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": ["*", "*.ts", "*.js"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/security/README.md

@@ -0,0 +1,116 @@
+# @naman_deep_singh/security
+
+Security utilities for password hashing and JWT token management with TypeScript support.
+
+## Installation
+
+```bash
+npm install @naman_deep_singh/security
+```
+
+## Features
+
+- ✅ **Password hashing** with bcrypt (salt rounds: 10)
+- ✅ **JWT token management** with configurable expiration
+- ✅ **TypeScript support** with full type safety
+- ✅ **Hybrid exports** - use named imports or namespace imports
+- ✅ **Backward compatibility** with legacy function names
+- ✅ **Async/await support** for all operations
+
+## Usage
+
+### Named Imports (Tree-shakable)
+```typescript
+import { hashPassword, verifyPassword, generateToken, verifyToken } from '@naman_deep_singh/security';
+
+// Password hashing
+const hashedPassword = await hashPassword('mypassword');
+const isValid = await verifyPassword('mypassword', hashedPassword);
+
+// JWT tokens
+const token = generateToken({ userId: 1, role: 'admin' }, 'your-secret-key', '24h');
+const decoded = verifyToken(token, 'your-secret-key');
+```
+
+### Namespace Import
+```typescript
+import SecurityUtils from '@naman_deep_singh/security';
+
+const hashedPassword = await SecurityUtils.hashPassword('mypassword');
+const token = SecurityUtils.generateToken({ userId: 1 }, 'secret');
+```
+
+### Backward Compatibility
+```typescript
+import { comparePassword, signToken } from '@naman_deep_singh/security';
+
+// Legacy function names still work
+const isValid = await comparePassword('password', 'hash');
+const token = signToken({ userId: 1 }, 'secret');
+```
+
+## API Reference
+
+### Password Functions
+- `hashPassword(password: string): Promise<string>` - Hash a password using bcrypt with salt rounds 10
+- `verifyPassword(password: string, hash: string): Promise<boolean>` - Verify password against hash
+- `comparePassword(password: string, hash: string): Promise<boolean>` - Alias for verifyPassword (backward compatibility)
+
+### JWT Functions
+- `generateToken(payload: Record<string, unknown>, secret: Secret, expiresIn?: string): string` - Generate JWT token
+- `verifyToken(token: string, secret: Secret): string | JwtPayload` - Verify and decode JWT token
+- `signToken(payload: Record<string, unknown>, secret: Secret, expiresIn?: string): string` - Alias for generateToken (backward compatibility)
+
+## Examples
+
+### Complete Authentication Flow
+```typescript
+import { hashPassword, verifyPassword, generateToken, verifyToken } from '@naman_deep_singh/security';
+
+// Registration
+async function registerUser(email: string, password: string) {
+  const hashedPassword = await hashPassword(password);
+  // Save user with hashedPassword to database
+  return { email, password: hashedPassword };
+}
+
+// Login
+async function loginUser(email: string, password: string, storedHash: string) {
+  const isValid = await verifyPassword(password, storedHash);
+  
+  if (!isValid) {
+    throw new Error('Invalid credentials');
+  }
+  
+  const token = generateToken(
+    { email, loginTime: Date.now() },
+    process.env.JWT_SECRET!,
+    '7d'
+  );
+  
+  return { token };
+}
+
+// Verify JWT
+function authenticateRequest(token: string) {
+  try {
+    const decoded = verifyToken(token, process.env.JWT_SECRET!);
+    return decoded;
+  } catch (error) {
+    throw new Error('Invalid token');
+  }
+}
+```
+
+## Dependencies
+
+- **bcryptjs** - For secure password hashing
+- **jsonwebtoken** - For JWT token management
+
+## Security Best Practices
+
+1. **Use strong secrets** for JWT signing (minimum 32 characters)
+2. **Set appropriate expiration times** for tokens
+3. **Store JWT secrets in environment variables**
+4. **Never log or expose hashed passwords**
+5. **Use HTTPS** in production for token transmission

package/packages/security/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@naman_deep_singh/security",
+  "version": "1.0.4",
+  "description": "Security utilities for password hashing and JWT token management with TypeScript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "security",
+    "jwt",
+    "bcrypt",
+    "authentication",
+    "password",
+    "token"
+  ],
+  "author": "Naman Deep Singh",
+  "license": "ISC",
+  "packageManager": "pnpm@10.20.0",
+  "dependencies": {
+    "bcryptjs": "^3.0.3",
+    "jsonwebtoken": "^9.0.2"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/jsonwebtoken": "^9.0.10",
+    "typescript": "^5.9.3"
+  }
+}

package/packages/security/src/index.ts

@@ -0,0 +1,39 @@
+import jwt, { Secret, JwtPayload } from "jsonwebtoken";
+import bcrypt from "bcryptjs";
+
+// 🧱 Password helpers
+export const hashPassword = async (password: string): Promise<string> => {
+  const salt = await bcrypt.genSalt(10);
+  return bcrypt.hash(password, salt);
+};
+
+export const verifyPassword = async (password: string, hash: string): Promise<boolean> => {
+  return bcrypt.compare(password, hash);
+};
+
+// For backward compatibility
+export const comparePassword = verifyPassword;
+
+// 🧩 JWT helpers
+export const generateToken = (payload: Record<string, unknown>, secret: Secret, expiresIn = "1h"): string => {
+  return jwt.sign(payload, secret, { expiresIn, algorithm: "HS256" } as jwt.SignOptions);
+};
+
+export const verifyToken = (token: string, secret: Secret): string | JwtPayload => {
+  return jwt.verify(token, secret);
+};
+
+// For backward compatibility
+export const signToken = generateToken;
+
+// Default export for namespace usage
+const SecurityUtils = {
+  hashPassword,
+  verifyPassword,
+  comparePassword,
+  generateToken,
+  verifyToken,
+  signToken
+};
+
+export default SecurityUtils;

package/packages/security/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": ["*", "*.ts", "*.js"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}