@medi-car-bd/mcb-shared-auth 0.0.7 → 0.0.12

package/README.md

@@ -32,21 +32,13 @@ pnpm prisma:migrate
 - Shared Auth package installation
 
 ```bash
-set GITHUB_TOKEN="your_github_token"
+npm login
 
-npm config set //registry.npmjs.org/:_authToken "your_npm_token"
-
-pnpm install @mcb-shared-auth/auth
-```
-
-#Or Use
+npm version patch
 
-```bash
-pnpm install github:Medi-Car-BD/mcb-shared-auth
-```
+npm config set //registry.npmjs.org/:_authToken=npm_xxxxxxxxxxxxxxxxx
 
-- Patched version of the shared auth package
+npm publish --access public
 
-```bash
-npm version patch
+pnpm install @mcb-shared-auth/auth
 ```

package/dist/config/env.d.ts

@@ -2,4 +2,5 @@ import "dotenv/config";
 declare const NODE_ENV: string | undefined;
 declare const JWT_SECRET: string | undefined;
 declare const JWT_EXPIRES_IN: string | undefined;
-export { NODE_ENV, JWT_SECRET, JWT_EXPIRES_IN };
+declare const GITHUB_TOKEN: string | undefined;
+export { NODE_ENV, JWT_SECRET, JWT_EXPIRES_IN, GITHUB_TOKEN };

package/dist/config/env.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JWT_EXPIRES_IN = exports.JWT_SECRET = exports.NODE_ENV = void 0;
+exports.GITHUB_TOKEN = exports.JWT_EXPIRES_IN = exports.JWT_SECRET = exports.NODE_ENV = void 0;
 require("dotenv/config");
 const NODE_ENV = process.env.NODE_ENV;
 exports.NODE_ENV = NODE_ENV;
@@ -8,3 +8,5 @@ const JWT_SECRET = process.env.JWT_SECRET;
 exports.JWT_SECRET = JWT_SECRET;
 const JWT_EXPIRES_IN = process.env.JWT_EXPIRES_IN;
 exports.JWT_EXPIRES_IN = JWT_EXPIRES_IN;
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN;
+exports.GITHUB_TOKEN = GITHUB_TOKEN;

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./userType";
 export * from "./commonType";
+export * from "./jwt";

package/dist/types/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./userType"), exports);
 __exportStar(require("./commonType"), exports);
+__exportStar(require("./jwt"), exports);

package/dist/types/jwt.d.ts

@@ -0,0 +1,97 @@
+/**
+ * The user shape that token utilities accept.
+ *
+ * `role` and `tenantId` are authorization claims, not decoration: `authorize`
+ * reads `role` and every client scopes data by `tenantId`, so they must survive
+ * both initial issuance and refresh rotation. Persistence shape (Prisma) allows
+ * nulls; the signed payload omits empty values.
+ */
+export interface AccessTokenPayload {
+    sub: string;
+    email: string;
+    name?: string;
+    role?: string;
+    tenantId?: string;
+    type: "access";
+    jti?: string;
+}
+export interface RefreshTokenPayload {
+    sub: string;
+    type: "refresh";
+    jti: string;
+}
+export interface TokenConfig {
+    accessTokenExpiresIn: string | number;
+    refreshTokenExpiresIn: string | number;
+    jwtSecret: string;
+    refreshTokenSecret?: string;
+}
+export interface RefreshTokenRecord {
+    id: string;
+    userId: string;
+    token: string;
+    deviceInfo?: string;
+    ipAddress?: string;
+    expiresAt: Date;
+    revokedAt?: Date | null;
+    replacedBy?: string | null;
+    lastUsedAt?: Date | null;
+    user?: {
+        id: string;
+        email: string;
+        name?: string | null;
+        role?: string | null;
+        tenantId?: string | null;
+    };
+}
+export interface RefreshTokenRepository {
+    create(record: RefreshTokenRecord): Promise<void>;
+    findById(id: string): Promise<RefreshTokenRecord | null>;
+    update(id: string, data: Partial<RefreshTokenRecord>): Promise<void>;
+    updateMany(where: {
+        userId: string;
+        revokedAt?: null;
+        id?: {
+            not: string;
+        };
+    }, data: {
+        revokedAt: Date;
+    }): Promise<{
+        count: number;
+    }>;
+}
+export interface GenerateTokenPairParams {
+    user: {
+        id: string;
+        email: string;
+        name?: string | null;
+        role?: string | null;
+        tenantId?: string | null;
+    };
+    deviceInfo?: string;
+    ipAddress?: string;
+    config: TokenConfig;
+    repo: RefreshTokenRepository;
+}
+export interface TokenPair {
+    accessToken: string;
+    refreshToken: string;
+}
+export interface RevokeAllUserTokensParams {
+    userId: string;
+    excludeTokenId?: string;
+    reason?: "password_change" | "security" | "admin_revocation";
+    repo: RefreshTokenRepository;
+}
+export interface RotateRefreshTokenParams {
+    oldRefreshToken: string;
+    deviceInfo?: string;
+    ipAddress?: string;
+    config: TokenConfig;
+    repo: RefreshTokenRepository;
+}
+export interface RotateRefreshTokenResult {
+    accessToken: string;
+    refreshToken: string;
+    userId: string;
+}

package/dist/types/jwt.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * The user shape that token utilities accept.
+ *
+ * `role` and `tenantId` are authorization claims, not decoration: `authorize`
+ * reads `role` and every client scopes data by `tenantId`, so they must survive
+ * both initial issuance and refresh rotation. Persistence shape (Prisma) allows
+ * nulls; the signed payload omits empty values.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/userType.d.ts

@@ -3,7 +3,7 @@ export type TUser = {
     name: string | null;
     email: string;
     image?: string | null;
-    password: string;
+    password?: string;
     createdAt?: Date;
     updatedAt?: Date;
 };

package/dist/utils/generateAccessToken.d.ts

@@ -0,0 +1,15 @@
+import type { TokenConfig } from "../types";
+/**
+ * Generate a new access token
+ *
+ * `role` and `tenantId` are signed into the payload because clients authorize
+ * and scope data from the token alone, without a database round trip. Empty
+ * values are omitted rather than serialized as null.
+ */
+export declare const generateAccessToken: (user: {
+    id: string;
+    email: string;
+    name?: string | null;
+    role?: string | null;
+    tenantId?: string | null;
+}, config: TokenConfig, jti?: string) => string;

package/dist/utils/generateAccessToken.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAccessToken = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+/**
+ * Generate a new access token
+ *
+ * `role` and `tenantId` are signed into the payload because clients authorize
+ * and scope data from the token alone, without a database round trip. Empty
+ * values are omitted rather than serialized as null.
+ */
+const generateAccessToken = (user, config, jti) => {
+    const payload = {
+        sub: user.id,
+        email: user.email,
+        name: user.name || undefined,
+        role: user.role || undefined,
+        tenantId: user.tenantId || undefined,
+        type: "access",
+        jti,
+    };
+    return jsonwebtoken_1.default.sign(payload, config.jwtSecret, {
+        expiresIn: config.accessTokenExpiresIn,
+        audience: "mcb-services",
+        issuer: "mcb-auth",
+    });
+};
+exports.generateAccessToken = generateAccessToken;

package/dist/utils/generateRefreshToken.d.ts

@@ -0,0 +1,10 @@
+import type { TokenConfig } from "../types";
+/**
+ * Generate a new refresh token (returns both the raw token and its hash)
+ */
+export declare const generateRefreshToken: (user: {
+    id: string;
+}, config: TokenConfig, tokenId: string) => {
+    token: string;
+    hashedToken: string;
+};

package/dist/utils/generateRefreshToken.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRefreshToken = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const hashToken_1 = require("./hashToken");
+/**
+ * Generate a new refresh token (returns both the raw token and its hash)
+ */
+const generateRefreshToken = (user, config, tokenId) => {
+    const payload = {
+        sub: user.id,
+        type: "refresh",
+        jti: tokenId,
+    };
+    // Use refresh token secret if provided, otherwise use main secret
+    const secret = config.refreshTokenSecret || config.jwtSecret;
+    const token = jsonwebtoken_1.default.sign(payload, secret, {
+        expiresIn: config.refreshTokenExpiresIn,
+        audience: "mcb-services",
+        issuer: "mcb-auth",
+    });
+    return {
+        token,
+        hashedToken: (0, hashToken_1.hashToken)(token),
+    };
+};
+exports.generateRefreshToken = generateRefreshToken;

package/dist/utils/generateTokenId.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate a unique token ID
+ */
+export declare const generateTokenId: () => string;

package/dist/utils/generateTokenId.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTokenId = void 0;
+const crypto_1 = require("crypto");
+/**
+ * Generate a unique token ID
+ */
+const generateTokenId = () => {
+    return (0, crypto_1.randomBytes)(32).toString("hex");
+};
+exports.generateTokenId = generateTokenId;

package/dist/utils/generateTokenPair.d.ts

@@ -0,0 +1,2 @@
+import type { GenerateTokenPairParams, TokenPair } from "../types";
+export declare const generateTokenPair: ({ user, deviceInfo, ipAddress, config, repo, }: GenerateTokenPairParams) => Promise<TokenPair>;

package/dist/utils/generateTokenPair.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTokenPair = void 0;
+const generateRefreshToken_1 = require("./generateRefreshToken");
+const generateAccessToken_1 = require("./generateAccessToken");
+const generateTokenId_1 = require("./generateTokenId");
+/**
+ * Store the refresh token in the database
+ */
+const storeRefreshToken = (tokenData, repo) => __awaiter(void 0, void 0, void 0, function* () {
+    yield repo.create(tokenData);
+});
+const generateTokenPair = (_a) => __awaiter(void 0, [_a], void 0, function* ({ user, deviceInfo, ipAddress, config, repo, }) {
+    try {
+        // Generate unique token ID for refresh token
+        const tokenId = (0, generateTokenId_1.generateTokenId)();
+        // Generate refresh token (raw and hashed)
+        const { token: refreshToken, hashedToken } = (0, generateRefreshToken_1.generateRefreshToken)(user, config, tokenId);
+        // Store refresh token in database
+        yield storeRefreshToken({
+            id: tokenId,
+            userId: user.id,
+            token: hashedToken,
+            deviceInfo,
+            ipAddress,
+            expiresAt: typeof config.refreshTokenExpiresIn === "number"
+                ? new Date(Date.now() + config.refreshTokenExpiresIn * 1000)
+                : new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
+            revokedAt: null,
+            replacedBy: null,
+            lastUsedAt: null,
+        }, repo);
+        // Generate access token with optional reference to refresh token
+        const accessToken = (0, generateAccessToken_1.generateAccessToken)(user, config, tokenId);
+        return {
+            accessToken,
+            refreshToken,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to generate token pair: ${error instanceof Error ? error.message : String(error)}`);
+    }
+});
+exports.generateTokenPair = generateTokenPair;

package/dist/utils/hashToken.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Hash a token for storage (never store raw tokens in DB)
+ */
+export declare const hashToken: (token: string) => string;

package/dist/utils/hashToken.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashToken = void 0;
+const crypto_1 = require("crypto");
+/**
+ * Hash a token for storage (never store raw tokens in DB)
+ */
+const hashToken = (token) => {
+    return (0, crypto_1.createHash)("sha256").update(token).digest("hex");
+};
+exports.hashToken = hashToken;

package/dist/utils/index.d.ts

@@ -5,3 +5,9 @@ export * from "./comparePassword";
 export * from "./signToken";
 export * from "./globalError";
 export * from "./limiter";
+export * from "./generateTokenPair";
+export * from "./generateRefreshToken";
+export * from "./rotateRefreshToken";
+export * from "./generateAccessToken";
+export * from "./hashToken";
+export * from "./generateTokenId";

package/dist/utils/index.js

@@ -21,3 +21,9 @@ __exportStar(require("./comparePassword"), exports);
 __exportStar(require("./signToken"), exports);
 __exportStar(require("./globalError"), exports);
 __exportStar(require("./limiter"), exports);
+__exportStar(require("./generateTokenPair"), exports);
+__exportStar(require("./generateRefreshToken"), exports);
+__exportStar(require("./rotateRefreshToken"), exports);
+__exportStar(require("./generateAccessToken"), exports);
+__exportStar(require("./hashToken"), exports);
+__exportStar(require("./generateTokenId"), exports);

package/dist/utils/rotateRefreshToken.d.ts

@@ -0,0 +1,9 @@
+import type { RevokeAllUserTokensParams, RotateRefreshTokenParams, RotateRefreshTokenResult } from "../types";
+/**
+ * Main function to rotate refresh token
+ */
+export declare const rotateRefreshToken: ({ oldRefreshToken, deviceInfo, ipAddress, config, repo, }: RotateRefreshTokenParams) => Promise<RotateRefreshTokenResult>;
+/**
+ * Revoke all tokens for a user
+ */
+export declare const revokeAllUserTokens: ({ userId, excludeTokenId, reason, repo, }: RevokeAllUserTokensParams) => Promise<number>;

package/dist/utils/rotateRefreshToken.js

@@ -0,0 +1,153 @@
+"use strict";
+// In mcb-shared-auth
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revokeAllUserTokens = exports.rotateRefreshToken = void 0;
+const crypto_1 = require("crypto");
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const generateTokenPair_1 = require("./generateTokenPair");
+/**
+ * Verify and decode refresh token
+ */
+const verifyRefreshToken = (token, config) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const secret = config.refreshTokenSecret || config.jwtSecret;
+        const decoded = jsonwebtoken_1.default.verify(token, secret, {
+            audience: "mcb-services",
+            issuer: "mcb-auth",
+        });
+        if (decoded.type !== "refresh") {
+            throw new Error("Invalid token type");
+        }
+        return decoded;
+    }
+    catch (error) {
+        throw new Error("Invalid refresh token: " + error.message);
+    }
+});
+/**
+ * Find and validate stored refresh token
+ */
+const findAndValidateStoredToken = (token, jti, repo) => __awaiter(void 0, void 0, void 0, function* () {
+    const hashedToken = (0, crypto_1.createHash)("sha256").update(token).digest("hex");
+    const storedToken = yield repo.findById(jti);
+    if (!storedToken) {
+        throw new Error("Refresh token not found");
+    }
+    // Check if token matches
+    if (storedToken.token !== hashedToken) {
+        throw new Error("Token mismatch");
+    }
+    // Check if token is revoked
+    if (storedToken.revokedAt) {
+        throw new Error("Token has been revoked");
+    }
+    // Check if token has been replaced
+    if (storedToken.replacedBy) {
+        throw new Error("Token has already been used (possible replay attack)");
+    }
+    // Check if token is expired
+    if (storedToken.expiresAt < new Date()) {
+        throw new Error("Refresh token expired");
+    }
+    return storedToken;
+});
+/**
+ * Mark old token as replaced
+ */
+const markTokenAsReplaced = (oldTokenId, newTokenId, repo) => __awaiter(void 0, void 0, void 0, function* () {
+    yield repo.update(oldTokenId, {
+        replacedBy: newTokenId,
+        lastUsedAt: new Date(),
+    });
+});
+/**
+ * Update last used timestamp
+ */
+const updateTokenLastUsed = (tokenId, ipAddress, repo) => __awaiter(void 0, void 0, void 0, function* () {
+    if (repo) {
+        yield repo.update(tokenId, {
+            lastUsedAt: new Date(),
+            ipAddress,
+        });
+    }
+});
+/**
+ * Main function to rotate refresh token
+ */
+const rotateRefreshToken = (_a) => __awaiter(void 0, [_a], void 0, function* ({ oldRefreshToken, deviceInfo, ipAddress, config, repo, }) {
+    try {
+        // 1. Verify the old refresh token
+        const decoded = yield verifyRefreshToken(oldRefreshToken, config);
+        // 2. Find and validate stored token
+        const storedToken = yield findAndValidateStoredToken(oldRefreshToken, decoded.jti, repo);
+        // 3. Generate new token pair
+        const newTokens = yield (0, generateTokenPair_1.generateTokenPair)({
+            user: storedToken.user,
+            deviceInfo: deviceInfo || storedToken.deviceInfo,
+            ipAddress: ipAddress || storedToken.ipAddress,
+            config,
+            repo,
+        });
+        // 4. Decode new refresh token to get its JTI
+        const newDecoded = jsonwebtoken_1.default.decode(newTokens.refreshToken);
+        // 5. Mark old token as replaced
+        yield markTokenAsReplaced(storedToken.id, newDecoded.jti, repo);
+        // 6. Update last used on old token (optional, can be omitted if replaced)
+        yield updateTokenLastUsed(storedToken.id, ipAddress, repo);
+        return {
+            accessToken: newTokens.accessToken,
+            refreshToken: newTokens.refreshToken,
+            userId: storedToken.userId,
+        };
+    }
+    catch (error) {
+        // Log security events for monitoring
+        console.error("Token rotation failed:", {
+            error: error.message,
+            ipAddress,
+            deviceInfo,
+            timestamp: new Date().toISOString(),
+        });
+        throw new Error(`Token rotation failed: ${error.message}`);
+    }
+});
+exports.rotateRefreshToken = rotateRefreshToken;
+/**
+ * Revoke all tokens for a user
+ */
+const revokeAllUserTokens = (_a) => __awaiter(void 0, [_a], void 0, function* ({ userId, excludeTokenId, reason = "security", repo, }) {
+    try {
+        const where = {
+            userId,
+            revokedAt: null,
+        };
+        if (excludeTokenId) {
+            where.id = { not: excludeTokenId };
+        }
+        const result = yield repo.updateMany(where, { revokedAt: new Date() });
+        // Log security event
+        console.log("Tokens revoked:", {
+            userId,
+            count: result.count,
+            reason,
+            timestamp: new Date().toISOString(),
+        });
+        return result.count;
+    }
+    catch (error) {
+        throw new Error(`Failed to revoke user tokens: ${error.message}`);
+    }
+});
+exports.revokeAllUserTokens = revokeAllUserTokens;

package/dist/utils/signToken.js

@@ -11,7 +11,6 @@ const signToken = (user) => {
         id: user.id,
         name: user.name,
         email: user.email,
-        password: user.password,
     }, config_1.JWT_SECRET, {
         expiresIn: config_1.JWT_EXPIRES_IN,
     });

package/package.json

@@ -1,63 +1,64 @@
-{
-  "name": "@medi-car-bd/mcb-shared-auth",
-  "version": "0.0.7",
-  "description": "Shared authentication module for MCB applications",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "preinstall": "node -e \"\"",
-    "postinstall": "",
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "lint": "eslint . --ext .ts,.tsx,.js,.jsx",
-    "lint:fix": "eslint . --ext .ts,.tsx,.js,.jsx --fix",
-    "format": "prettier --write .",
-    "format:check": "prettier --check ."
-  },
-  "keywords": [],
-  "author": "MediCarBD",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/bcryptjs": "^2.4.6",
-    "@types/express": "^4.17.21",
-    "@types/jsonwebtoken": "^9.0.5",
-    "@types/node": "^20.11.0",
-    "@typescript-eslint/eslint-plugin": "^8.54.0",
-    "@typescript-eslint/parser": "^8.54.0",
-    "eslint": "^9.39.2",
-    "eslint-config-prettier": "^9.1.0",
-    "prettier": "^3.2.5",
-    "typescript": "^5.3.3"
-  },
-  "dependencies": {
-    "bcryptjs": "^2.4.3",
-    "dotenv": "^16.3.1",
-    "express-rate-limit": "^7.1.5",
-    "jsonwebtoken": "^9.0.2",
-    "winston": "^3.11.0",
-    "winston-daily-rotate-file": "^4.7.1"
-  },
-  "peerDependencies": {
-    "express": "^4.18.2"
-  },
-  "files": [
-    "dist"
-  ],
-  "lint-staged": {
-    "*.{ts,tsx,js,jsx}": [
-      "eslint --max-warnings=0 --fix",
-      "prettier --write"
-    ],
-    "*.{json,md,yml,yaml}": [
-      "prettier --write"
-    ]
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Medi-Car-BD/mcb-shared-auth"
-  }
-}
+{
+  "name": "@medi-car-bd/mcb-shared-auth",
+  "version": "0.0.12",
+  "description": "Shared authentication module for MCB applications",
+  "packageManager": "pnpm@10.18.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "preinstall": "node -e \"\"",
+    "postinstall": "",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint . --ext .ts,.tsx,.js,.jsx",
+    "lint:fix": "eslint . --ext .ts,.tsx,.js,.jsx --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
+  },
+  "keywords": [],
+  "author": "MediCarBD",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/express": "^4.17.21",
+    "@types/jsonwebtoken": "^9.0.5",
+    "@types/node": "^20.11.0",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.2.5",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "dotenv": "^16.3.1",
+    "express-rate-limit": "^7.1.5",
+    "jsonwebtoken": "^9.0.2",
+    "winston": "^3.11.0",
+    "winston-daily-rotate-file": "^4.7.1"
+  },
+  "peerDependencies": {
+    "express": "^4.18.2"
+  },
+  "files": [
+    "dist"
+  ],
+  "lint-staged": {
+    "*.{ts,tsx,js,jsx}": [
+      "eslint --max-warnings=0 --fix",
+      "prettier --write"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mcb-org/mcb-shared-auth.git"
+  }
+}