abhijanb 0.1.0 → 0.1.1

package/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/index.ts

@@ -1,12 +1,5 @@
-/** 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";
+/** 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";
 
@@ -15,6 +8,17 @@ 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;
+/** 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";
+
+/** Validate data against Zod schema: `validate(schema, data)` → { success, data, errors } */
+export { validate } from "./validate";
+export type { ValidateResult } from "./validate";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abhijanb",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "module": "index.ts",
   "type": "module",
   "exports": {
@@ -8,15 +8,18 @@
   },
   "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/socket.ts

@@ -1,10 +1,17 @@
+import http from "http";
 import { Server } from "socket.io";
-import { server } from "./app";
+import type { Express } from "express";
 
-const io = new Server(server);
-const socket = io;
+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 };
+}
 
-/** Socket.IO server instance — use for `.on()` / `.emit()` */
 export { io, socket };
-/** Socket type — for typing event handlers */
 export type { Socket } from "socket.io";

package/validate.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import type { ZodSchema, ZodIssue } from "zod";
+
+type ValidateResult<T> =
+  | { success: true; data: T; errors: null }
+  | { success: false; data: null; errors: ZodIssue[] };
+
+/** Validate data against a Zod schema: `validate(schema, data)` → { 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: result.error.issues };
+}
+
+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";