abhijanb 0.1.1 → 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,24 +1,3 @@
-/** 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";
-
-/** Validate data against Zod schema: `validate(schema, data)` → { success, data, errors } */
-export { validate } from "./validate";
-export type { ValidateResult } from "./validate";
+/** Main entry point — re-exports everything from util/ and lib/ */
+export * from "./util";
+export * from "./lib";

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/package.json

@@ -1,10 +1,12 @@
 {
   "name": "abhijanb",
-  "version": "0.1.1",
+  "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": {

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/validate.ts

@@ -1,17 +0,0 @@
-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 };