abhijanb 0.1.0 → 0.1.2

package/a/README.md

@@ -0,0 +1,15 @@
+# a
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.14. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/a/index.ts

@@ -0,0 +1,26 @@
+import { startSocket, validate } from 'abhijanb';
+import express from 'express';
+import z from 'zod';
+const app = express();
+const {server} = startSocket(app);
+
+
+const schema = z.object({
+  name: z.string(),
+  age: z.number().int().positive(),
+});
+
+app.use(express.json());
+
+app.post('/validate', (req, res) => {
+  const result = validate(schema, req.body);
+  if (result.success) {
+    res.json({ message: 'Validation successful', data: result.data });
+  } else {
+    res.status(400).json({ message: 'Validation failed', errors: result.errors });
+  }
+});
+
+server.listen(3000, () => {
+  console.log('Server is running on port 3000');
+});

package/a/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "a",
+  "module": "index.ts",
+  "type": "module",
+  "private": true,
+  "scripts": {
+   "dev": "bun --watch index.ts"
+
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "abhijanb": "^0.1.1"
+  }
+}

package/index.ts

@@ -1,20 +1,3 @@
-/** Express app instance — use for routing and middleware */
-export { app, server } from "./app";
-/** Express types — Request, Response, NextFunction */
-export type { Request, Response, NextFunction } from "./app";
-/** Express utilities — Router, json, urlencoded, expressStatic */
-export { Router, json, urlencoded, expressStatic } from "./app";
-
-/** Socket.IO server instance — use for `.on()` / `.emit()` */
-export { io, socket } from "./socket";
-/** Socket type — for typing event handlers */
-export type { Socket } from "./socket";
-
-/** Rate limiter factory: `app.use(limiter(5, 1000))` = 5min window, 1000 req/IP */
-export { limiter } from "./rateLimiter";
-/** Factory — create custom rate limiters: `rateLimit({ windowMs: 60000, max: 20 })` */
-export { rateLimit } from "./rateLimiter";
-
-/** Default export — Express app instance */
-import { app } from "./app";
-export default app;
+/** Main entry point — re-exports everything from util/ and lib/ */
+export * from "./util";
+export * from "./lib";

package/lib/auth.ts

@@ -0,0 +1,71 @@
+import jwt from "jsonwebtoken";
+import type { Request, Response, NextFunction } from "express";
+
+const ACCESS_SECRET = process.env.JWT_ACCESS_SECRET || "access-secret";
+const REFRESH_SECRET = process.env.JWT_REFRESH_SECRET || "refresh-secret";
+const ACCESS_EXPIRY = "30m";
+const REFRESH_EXPIRY = "30d";
+
+/** Sign an access token */
+export function signToken(
+  payload: object,
+  options?: { secret?: string; expiresIn?: string }
+): string {
+  return jwt.sign(payload, options?.secret || ACCESS_SECRET, {
+    expiresIn: options?.expiresIn || ACCESS_EXPIRY,
+  });
+}
+
+/** Sign a refresh token */
+export function signRefreshToken(
+  payload: object,
+  options?: { secret?: string; expiresIn?: string }
+): string {
+  return jwt.sign(payload, options?.secret || REFRESH_SECRET, {
+    expiresIn: options?.expiresIn || REFRESH_EXPIRY,
+  });
+}
+
+/** Verify and decode a token */
+export function verifyToken<T = any>(
+  token: string,
+  options?: { secret?: string }
+): T {
+  return jwt.verify(token, options?.secret || ACCESS_SECRET) as T;
+}
+
+/** Refresh: verify refresh token → return new access token */
+export function refreshToken(
+  token: string,
+  options?: { accessSecret?: string; refreshSecret?: string }
+): string {
+  const decoded = jwt.verify(
+    token,
+    options?.refreshSecret || REFRESH_SECRET
+  ) as jwt.JwtPayload;
+
+  const { iat, exp, ...payload } = decoded;
+  return signToken(payload, { secret: options?.accessSecret });
+}
+
+/** Express middleware — verifies Bearer token, attaches decoded payload to `req.user` */
+export function authMiddleware(options?: { secret?: string }) {
+  return (req: Request, res: Response, next: NextFunction) => {
+    const header = req.headers.authorization;
+
+    if (!header || !header.startsWith("Bearer ")) {
+      res.status(401).json({ error: "Missing or invalid Authorization header" });
+      return;
+    }
+
+    const token = header.split(" ")[1];
+
+    try {
+      const decoded = jwt.verify(token, options?.secret || ACCESS_SECRET);
+      (req as any).user = decoded;
+      next();
+    } catch {
+      res.status(401).json({ error: "Invalid or expired token" });
+    }
+  };
+}

package/lib/index.ts

@@ -0,0 +1,20 @@
+/** Start Socket.IO on an Express app: `startSocket(app)` → returns { server, io, socket } */
+export { startSocket, io, socket } from "./socket";
+/** Socket type — for typing event handlers */
+export type { Socket } from "./socket";
+
+/** Rate limiter factory: `app.use(limiter(5, 1000))` = 5min window, 1000 req/IP */
+export { limiter } from "./rateLimiter";
+/** Factory — create custom rate limiters: `rateLimit({ windowMs: 60000, max: 20 })` */
+export { rateLimit } from "./rateLimiter";
+
+/** JWT middleware — verifies Bearer token, attaches decoded payload to `req.user` */
+export { authMiddleware } from "./auth";
+/** Sign an access token: `signToken({ userId: 1 })` */
+export { signToken } from "./auth";
+/** Sign a refresh token: `signRefreshToken({ userId: 1 })` */
+export { signRefreshToken } from "./auth";
+/** Verify and decode a token: `verifyToken<T>(token)` */
+export { verifyToken } from "./auth";
+/** Refresh: verify refresh token → return new access token */
+export { refreshToken } from "./auth";

package/lib/socket.ts

@@ -0,0 +1,17 @@
+import http from "http";
+import { Server } from "socket.io";
+import type { Express } from "express";
+
+let io: Server;
+let socket: Server;
+
+/** Start Socket.IO on an Express app: `startSocket(app)` → returns { server, io, socket } */
+export function startSocket(app: Express) {
+  const server = http.createServer(app);
+  io = new Server(server);
+  socket = io;
+  return { server, io, socket };
+}
+
+export { io, socket };
+export type { Socket } from "socket.io";

package/package.json

@@ -1,22 +1,27 @@
 {
   "name": "abhijanb",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "module": "index.ts",
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./util": "./util/index.ts",
+    "./lib": "./lib/index.ts"
   },
   "types": "./index.ts",
   "dependencies": {
-    "express": "^4.21.0",
     "express-rate-limit": "^7.5.0",
-    "socket.io": "^4.8.0"
+    "jsonwebtoken": "^9.0.0",
+    "socket.io": "^4.8.0",
+    "zod": "^3.22.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "@types/express": "^5.0.0"
+    "@types/express": "^5.0.0",
+    "@types/jsonwebtoken": "^9.0.0"
   },
   "peerDependencies": {
+    "express": "^4.21.0",
     "typescript": "^5"
   }
 }

package/util/index.ts

@@ -0,0 +1,25 @@
+/** Validate data against Zod schema: `validate(schema, data)` → { success, data, errors } */
+export { validate } from "./validate";
+export type { ValidateResult } from "./validate";
+
+/** Response helpers: ok, created, badRequest, notFound, etc. */
+export {
+  ok,
+  created,
+  noContent,
+  paginated,
+  badRequest,
+  unauthorized,
+  forbidden,
+  notFound,
+  conflict,
+  internalError,
+  fail,
+}  from "./response";
+
+/** Response namespace: `response.ok(res, data)`, `response.created(res, data)` */
+export { response } from "./response";
+
+/** Status codes and error codes constants */
+export { STATUS_CODE, ERROR_CODES } from "./response";
+export type { StatusCode, ErrorCode, ApiResponse, ApiErrorResponse } from "./response";

package/util/response.ts

@@ -0,0 +1,116 @@
+import type { Response } from "express";
+
+const STATUS_CODE = {
+  OK: 200,
+  CREATED: 201,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  INTERNAL_SERVER_ERROR: 500,
+} as const;
+
+const ERROR_CODES = {
+  BAD_REQUEST: "BAD_REQUEST",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  NOT_FOUND: "NOT_FOUND",
+  CONFLICT: "CONFLICT",
+  INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR",
+} as const;
+
+type StatusCode = (typeof STATUS_CODE)[keyof typeof STATUS_CODE];
+type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
+
+type ApiResponse<T> = { success: true; data: T; meta?: Record<string, unknown> };
+type ApiErrorResponse = { success: false; error: { code: ErrorCode; message: string; details?: unknown } };
+
+function successResponse<T>(data: T, meta?: Record<string, unknown>): ApiResponse<T> {
+  return { success: true, data, ...(meta && { meta }) };
+}
+
+function errorResponse(code: ErrorCode, message: string, details?: unknown): ApiErrorResponse {
+  return { success: false, error: { code, message, details } };
+}
+
+export function ok<T>(res: Response, data: T, meta?: Record<string, unknown>) {
+  res.status(STATUS_CODE.OK).json(successResponse(data, meta));
+}
+
+export function created<T>(res: Response, data: T) {
+  res.status(STATUS_CODE.CREATED).json(successResponse(data));
+}
+
+export function noContent(res: Response) {
+  res.status(STATUS_CODE.NO_CONTENT).send();
+}
+
+export function paginated<T>(
+  res: Response,
+  items: T[],
+  pagination: { page: number; limit: number; totalItems: number }
+) {
+  res.status(STATUS_CODE.OK).json(
+    successResponse(items, {
+      pagination: {
+        page: pagination.page,
+        limit: pagination.limit,
+        totalItems: pagination.totalItems,
+        totalPages: Math.ceil(pagination.totalItems / pagination.limit),
+      },
+    })
+  );
+}
+
+export function fail(
+  res: Response,
+  { status, code, message, details }: { status: StatusCode; code: ErrorCode; message: string; details?: unknown }
+) {
+  res.status(status).json(errorResponse(code, message, details));
+}
+
+export function badRequest(res: Response, message: string, details?: unknown) {
+  fail(res, { status: STATUS_CODE.BAD_REQUEST, code: ERROR_CODES.BAD_REQUEST, message, details });
+}
+
+export function unauthorized(res: Response, message: string, details?: unknown) {
+  fail(res, { status: STATUS_CODE.UNAUTHORIZED, code: ERROR_CODES.UNAUTHORIZED, message, details });
+}
+
+export function forbidden(res: Response, message: string, details?: unknown) {
+  fail(res, { status: STATUS_CODE.FORBIDDEN, code: ERROR_CODES.FORBIDDEN, message, details });
+}
+
+export function notFound(res: Response, message: string, details?: unknown) {
+  fail(res, { status: STATUS_CODE.NOT_FOUND, code: ERROR_CODES.NOT_FOUND, message, details });
+}
+
+export function conflict(res: Response, message: string, details?: unknown) {
+  fail(res, { status: STATUS_CODE.CONFLICT, code: ERROR_CODES.CONFLICT, message, details });
+}
+
+export function internalError(res: Response, message: string, details?: unknown) {
+  fail(res, { status: STATUS_CODE.INTERNAL_SERVER_ERROR, code: ERROR_CODES.INTERNAL_SERVER_ERROR, message, details });
+}
+
+export { STATUS_CODE, ERROR_CODES };
+export type { StatusCode, ErrorCode, ApiResponse, ApiErrorResponse };
+
+/** Response helper namespace: `response.ok(res, data)`, `response.created(res, data)` */
+export const response = {
+  ok,
+  created,
+  noContent,
+  paginated,
+  badRequest,
+  unauthorized,
+  forbidden,
+  notFound,
+  conflict,
+  internalError,
+  fail,
+  STATUS_CODE,
+  ERROR_CODES,
+};

package/util/validate.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import type { ZodSchema, ZodError } from "zod";
+
+type FormattedError = { field: string; message: string; code: string };
+
+type ValidateResult<T> =
+  | { success: true; data: T; errors: null }
+  | { success: false; data: null; errors: FormattedError[] };
+
+function formatZodErrors(error: ZodError): FormattedError[] {
+  return error.issues.map((issue) => ({
+    field: issue.path.length ? issue.path.join(".") : "root",
+    message: issue.message,
+    code: issue.code,
+  }));
+}
+
+/** Validate data against Zod schema → { success, data, errors } */
+export function validate<T>(schema: ZodSchema<T>, data: unknown): ValidateResult<T> {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data, errors: null };
+  }
+  return { success: false, data: null, errors: formatZodErrors(result.error) };
+}
+
+export type { ValidateResult };

package/app.ts

@@ -1,14 +0,0 @@
-import express from "express";
-import http from "http";
-
-const app = express();
-const server = http.createServer(app);
-
-/** Express app instance — use for routing and middleware */
-export { app };
-/** HTTP server instance — used by Socket.IO */
-export { server };
-/** Express request type */
-export type { Request, Response, NextFunction } from "express";
-/** Router — create modular route handlers */
-export { Router, json, urlencoded, static as expressStatic } from "express";

package/socket.ts

@@ -1,10 +0,0 @@
-import { Server } from "socket.io";
-import { server } from "./app";
-
-const io = new Server(server);
-const socket = io;
-
-/** Socket.IO server instance — use for `.on()` / `.emit()` */
-export { io, socket };
-/** Socket type — for typing event handlers */
-export type { Socket } from "socket.io";