@carecard/jwt-read 1.0.5 → 3.0.1

package/index.js

@@ -0,0 +1,21 @@
+const jwtLib = require( './lib/jwtLib' );
+const jwtRoles = require( './lib/jwtRoles' );
+
+
+module.exports = {
+    verifyJwt: jwtLib.verifyJwt,
+    verifyWebToken: jwtLib.verifyWebToken,
+    verifyJwtNoThrow: jwtLib.verifyJwtNoThrow,
+    verifyWebTokenNoThrow: jwtLib.verifyWebTokenNoThrow,
+    verifyVisitorNoThrow: jwtLib.verifyVisitorNoThrow,
+    jwtClientId: jwtLib.jwtClientId,
+    visitorClientId: jwtLib.visitorClientId,
+    isJwtExpired: jwtLib.isJwtExpired,
+    jwtAgeInSeconds: jwtLib.jwtAgeInSeconds,
+    verifyJwtAndRole: jwtLib.verifyJwtAndRole,
+    throwUsedTokenError: jwtLib.throwUsedTokenError,
+    doesJwtUserHasRole: jwtLib.doesJwtUserHasRole,
+    getNameOfRole: jwtRoles.getNameOfRoleFromCode,
+    getCodeOfRole: jwtRoles.getCodeFromNameOfRole
+};
+

package/lib/jwtLib.js

@@ -0,0 +1,475 @@
+const validate = require( '@carecard/validate' ).validate;
+const { jwtUtilAuth } = require( '@carecard/auth-util' );
+const {
+    throwLoginRequiredError,
+    throwNotAuthorizedError
+} = require( "@carecard/common-util" ).error;
+
+function jwtClientId( req ) {
+    const jwtObj = req?.jwt || this;
+    return jwtObj?.payload?.client_id;
+}
+
+function visitorClientId( req ) {
+    const visitorObj = req?.visitor || this;
+    return visitorObj?.payload?.client_id;
+}
+
+function doesJwtUserHasRole( req, userRole ) {
+    // Check if called as req.jwt.doesJwtUserHasRole(userRole) or doesJwtUserHasRole(role)
+    if ( arguments.length === 1 && typeof req === 'string' ) {
+        userRole = req;
+        req = undefined;
+    }
+
+    const jwtObj = req?.jwt || this;
+
+    if ( userRole && typeof userRole === "string" ) {
+        return jwtObj?.payload?.roles?.includes( userRole );
+    } else {
+        throwNotAuthorizedError();
+    }
+}
+
+function throwError( customErrorFunction ) {
+    ( typeof customErrorFunction === "function" ) ?
+        customErrorFunction() :
+        throwLoginRequiredError()
+}
+
+function isJwtExpired( req, jwtValiditySeconds ) {
+    // Check if called as req.jwt.isJwtExpired(seconds) or isJwtExpired(seconds)
+    if ( arguments.length === 1 && typeof req === 'number' ) {
+        jwtValiditySeconds = req;
+        req = undefined;
+    }
+
+    if ( jwtValiditySeconds && typeof jwtValiditySeconds === "number" ) {
+        return ( parseInt( jwtValiditySeconds ) ) < jwtAgeInSeconds.call( this, req );
+    } else {
+        return true;
+    }
+
+}
+
+function jwtAgeInSeconds( req ) {
+    const jwtObj = req?.jwt || this;
+
+    if ( jwtObj?.payload?.iat ) {
+
+        let iat = jwtObj.payload.iat;
+        if ( iat > 1000000000000 ) {
+            iat = Math.floor( iat / 1000 );
+        }
+
+        jwtObj[ "age" ] = Math.floor( Date.now() / 1000 ) - iat;
+        return jwtObj.age;
+
+    } else {
+
+        jwtObj[ "age" ] = Infinity
+        return jwtObj.age;
+
+    }
+}
+
+async function validateAndExtractJwtObject( req, publicKey, customErrorFunction ) {
+
+    const jwtString = await _validateJwt( req, customErrorFunction );
+
+    const isJwtSignatureValid = await _isJwtSignatureValid( jwtString, publicKey, customErrorFunction );
+
+    if ( jwtString && isJwtSignatureValid ) {
+        await _extractJwtObject( req, jwtString, customErrorFunction );
+    } else {
+        req[ "jwt" ] = null;
+        throwError( customErrorFunction );
+    }
+
+    return req;
+}
+
+async function validateAndExtractWebToken( req, publicKey, headerName, customErrorFunction ) {
+
+    const webTokenString = await _validateWebToken( req, headerName, customErrorFunction );
+
+    const isJwtSignatureValid = await _isJwtSignatureValid( webTokenString, publicKey, customErrorFunction );
+
+    if ( webTokenString && isJwtSignatureValid ) {
+        await _extractJwtObject( req, webTokenString, customErrorFunction );
+    } else {
+        req[ "jwt" ] = null;
+        throwError( customErrorFunction );
+    }
+
+    return req;
+}
+
+async function validateAndExtractJwtObjectNoThrow( req, publicKey ) {
+
+    try {
+
+        const jwtString = await _validateJwtNoThrow( req );
+
+        const isJwtSignatureValid = await _isJwtSignatureValidNoThrow( jwtString, publicKey );
+
+        if ( jwtString && isJwtSignatureValid ) {
+            await _extractJwtObjectNoThrow( req, jwtString );
+        } else {
+            req[ "jwt" ] = null;
+        }
+
+    } catch ( err ) {
+
+        req[ "jwt" ] = null;
+
+    }
+
+    return req;
+}
+
+async function validateAndExtractWebTokenObjectNoThrow( req, publicKey, headerName ) {
+
+    try {
+
+        const jwtString = _validateWebTokenNoThrow( req, headerName );
+
+        const isJwtSignatureValid = await _isJwtSignatureValidNoThrow( jwtString, publicKey );
+
+        if ( jwtString && isJwtSignatureValid ) {
+            await _extractJwtObjectNoThrow( req, jwtString );
+        } else {
+            req[ "jwt" ] = null;
+        }
+
+    } catch ( err ) {
+
+        req[ "jwt" ] = null;
+
+    }
+
+    return req;
+}
+
+async function validateAndExtractVisitorObjectNoThrow( req, publicKey ) {
+
+    try {
+
+        const jwtString = await _validateVisitorNoThrow( req );
+
+        const isJwtSignatureValid = await _isJwtSignatureValidNoThrow( jwtString, publicKey );
+
+        if ( jwtString && isJwtSignatureValid ) {
+            await _extractVisitorObjectNoThrow( req, jwtString );
+        } else {
+            req[ "visitor" ] = null;
+        }
+
+    } catch ( err ) {
+
+        req[ "visitor" ] = null;
+
+    }
+
+    return req;
+}
+
+function verifyJwtAndRole( role, publicKey, customErrorFunction ) {
+    return async function ( req, res, next ) {
+        await validateAndExtractJwtObject( req, publicKey, customErrorFunction )
+            .then( req => doesJwtUserHasRole( req, role ) )
+            .then( isRoleExist => _isLoginRequired( isRoleExist, customErrorFunction ) )
+            .then( () => next() )
+            .catch( next );
+    }
+}
+
+function verifyJwt( publicKey, customErrorFunction ) {
+    return async function ( req, res, next ) {
+        await validateAndExtractJwtObject( req, publicKey, customErrorFunction )
+            .then( () => process.nextTick( next ) )
+            .catch( next );
+    }
+}
+
+function verifyWebToken( publicKey, headerName, customErrorFunction ) {
+    return async function ( req, res, next ) {
+        await validateAndExtractWebToken( req, publicKey, headerName, customErrorFunction )
+            .then( () => process.nextTick( next ) )
+            .catch( next );
+    }
+}
+
+function verifyJwtNoThrow( publicKey ) {
+    return async function ( req, res, next ) {
+        await validateAndExtractJwtObjectNoThrow( req, publicKey )
+            .then( () => process.nextTick( next ) )
+            .catch( next );
+    }
+}
+
+function verifyWebTokenNoThrow( publicKey, headerName ) {
+    return async function ( req, res, next ) {
+        await validateAndExtractWebTokenObjectNoThrow( req, publicKey, headerName )
+            .then( () => process.nextTick( next ) )
+            .catch( next );
+    }
+}
+
+function verifyVisitorNoThrow( publicKey ) {
+    return async function ( req, res, next ) {
+        await validateAndExtractVisitorObjectNoThrow( req, publicKey )
+            .then( () => process.nextTick( next ) )
+            .catch( next );
+    }
+}
+
+function throwUsedTokenError() {
+    throw new Error( "Used_Token" );
+}
+
+/*********************
+ * Private functions *
+ *********************/
+function _isLoginRequired( hasRequiredRole, customErrorFunction ) {
+
+    if ( !hasRequiredRole ) {
+        throwError( customErrorFunction );
+    }
+
+}
+
+async function _extractJwtObject( req, jwt, customErrorFunction ) {
+    if ( jwt && typeof jwt === "string" ) {
+        const jwtObj = jwtUtilAuth.getHeaderPayloadFromJwt( jwt );
+        _attachJwtMethods( jwtObj );
+        req[ "jwt" ] = jwtObj;
+    } else {
+        throwError( customErrorFunction );
+    }
+}
+
+async function _extractJwtObjectNoThrow( req, jwt ) {
+    if ( jwt && typeof jwt === "string" ) {
+        const jwtObj = jwtUtilAuth.getHeaderPayloadFromJwt( jwt );
+        _attachJwtMethods( jwtObj );
+        req[ "jwt" ] = jwtObj;
+    } else {
+        req[ "jwt" ] = null;
+    }
+}
+
+async function _extractVisitorObjectNoThrow( req, jwt ) {
+    if ( jwt && typeof jwt === "string" ) {
+        const visitorObj = jwtUtilAuth.getHeaderPayloadFromJwt( jwt );
+        _attachVisitorMethods( visitorObj );
+        req[ "visitor" ] = visitorObj;
+    } else {
+        req[ "visitor" ] = null;
+    }
+}
+
+function _attachJwtMethods( jwtObj ) {
+    if ( jwtObj ) {
+        Object.defineProperties( jwtObj, {
+            jwtClientId: { value: jwtClientId, enumerable: false },
+            doesJwtUserHasRole: { value: doesJwtUserHasRole, enumerable: false },
+            isJwtExpired: { value: isJwtExpired, enumerable: false },
+            jwtAgeInSeconds: { value: jwtAgeInSeconds, enumerable: false }
+        } );
+    }
+}
+
+function _attachVisitorMethods( visitorObj ) {
+    if ( visitorObj ) {
+        Object.defineProperties( visitorObj, {
+            visitorClientId: { value: visitorClientId, enumerable: false }
+        } );
+    }
+}
+
+async function _isJwtSignatureValid( jwt, publicKey, customErrorFunction ) {
+
+    if ( jwt && typeof jwt === "string" ) {
+        return jwtUtilAuth.verifyJwtSignature( jwt, publicKey )
+    } else {
+        throwError( customErrorFunction );
+    }
+}
+
+async function _isJwtSignatureValidNoThrow( jwt, publicKey ) {
+
+    if ( jwt && typeof jwt === "string" ) {
+        return jwtUtilAuth.verifyJwtSignature( jwt, publicKey )
+    } else {
+        return false;
+    }
+}
+
+async function _validateJwt( req, customErrorFunction ) {
+
+    // Get from http header.
+    let jwtRaw = req.get( "Authorization" );
+
+    // Extract jwt from bearer schema.
+    let jwt = _extractJwt( jwtRaw, customErrorFunction );
+
+    // Validate characters string of jwt.
+    if ( validate.isJwtString( jwt ) ) {
+        return jwt;
+    } else {
+        throwError( customErrorFunction );
+    }
+}
+
+async function _validateWebToken( req, headerName, customErrorFunction ) {
+
+    // Get from http header.
+    let jwtRaw = req.get( headerName );
+
+    // Extract jwt from bearer schema.
+    let webToken = _extractWebToken( jwtRaw, customErrorFunction );
+
+    // Validate characters string of jwt.
+    if ( validate.isJwtString( webToken ) ) {
+        return webToken;
+    } else {
+        throwError( customErrorFunction );
+    }
+}
+
+function _validateJwtNoThrow( req ) {
+
+    // Get from http header.
+    let jwtRaw = req.get( "Authorization" );
+
+    if ( !jwtRaw ) {
+        return null;
+    }
+
+    // Extract jwt from bearer schema.
+    let jwt = _extractJwtNoThrow( jwtRaw );
+
+    // Validate characters string of jwt.
+    if ( validate.isJwtString( jwt ) ) {
+        return jwt;
+    }
+
+    return null;
+}
+
+function _validateWebTokenNoThrow( req, headerName ) {
+
+    // Get from http header.
+    let jwtRaw = req.get( headerName );
+
+    if ( !jwtRaw ) {
+        return null;
+    }
+
+    // Extract jwt from bearer schema.
+    let webToken = _extractWebTokenNoThrow( jwtRaw );
+
+    // Validate characters string of jwt.
+    if ( validate.isJwtString( webToken ) ) {
+        return webToken;
+    }
+
+    return null;
+}
+
+function _validateVisitorNoThrow( req ) {
+
+    // Get from http header.
+    let jwtRaw = req.get( "Visitor" );
+
+    if ( !jwtRaw ) {
+        return null;
+    }
+
+    // Extract jwt from bearer schema.
+    let jwt = _extractJwtNoThrow( jwtRaw );
+
+    // Validate characters string of jwt.
+    if ( validate.isJwtString( jwt ) ) {
+        return jwt;
+    }
+
+    return null;
+}
+
+function _extractJwt( jwtRaw, customErrorFunction ) {
+    let jwtSplit = null;
+
+    if ( jwtRaw && typeof jwtRaw === "string" ) {
+        jwtSplit = jwtRaw.split( " " );
+    } else {
+        throwError( customErrorFunction );
+    }
+
+    if ( jwtSplit[ 0 ]?.toLowerCase() === "bearer" ) {
+        return jwtSplit[ 1 ];
+    } else {
+        throwError( customErrorFunction );
+    }
+
+    return null;
+}
+
+function _extractWebToken( jwtRaw, customErrorFunction ) {
+
+    if ( jwtRaw && typeof jwtRaw === "string" ) {
+        return jwtRaw;
+    } else {
+        throwError( customErrorFunction );
+    }
+
+    return null;
+}
+
+function _extractJwtNoThrow( jwtRaw ) {
+    let jwtSplit = null;
+
+    if ( jwtRaw && typeof jwtRaw === "string" ) {
+        jwtSplit = jwtRaw.split( " " );
+    } else {
+        return null;
+    }
+
+    if ( jwtSplit[ 0 ]?.toLowerCase() === "bearer" ) {
+        return jwtSplit[ 1 ];
+    }
+
+    return null;
+}
+
+function _extractWebTokenNoThrow( jwtRaw ) {
+
+    if ( jwtRaw && typeof jwtRaw === "string" ) {
+        return jwtRaw;
+    }
+    return null;
+}
+
+module.exports = {
+    _validateJwt,
+    _validateJwtNoThrow,
+    _isJwtSignatureValid,
+    _isJwtSignatureValidNoThrow,
+    _extractJwtObject,
+    _extractJwtObjectNoThrow,
+    validateAndExtractJwtObject,
+    jwtAgeInSeconds,
+    isJwtExpired,
+    doesJwtUserHasRole,
+    jwtClientId,
+    visitorClientId,
+    verifyJwtAndRole,
+    verifyJwt,
+    verifyWebTokenNoThrow,
+    verifyWebToken,
+    verifyJwtNoThrow,
+    throwUsedTokenError,
+    throwError,
+    verifyVisitorNoThrow
+}

package/lib/jwtRoles.js

@@ -0,0 +1,20 @@
+module.exports = {
+    getNameOfRoleFromCode,
+    getCodeFromNameOfRole,
+}
+
+function getNameOfRoleFromCode( roleCode ) {
+    const codesToCategory = {
+        "ad": "admin",
+        "su": "super_admin",
+    }
+    return codesToCategory[ roleCode ] || "";
+}
+
+function getCodeFromNameOfRole( roleCode ) {
+    const codesToCategory = {
+        "admin": "ad",
+        "super_admin": "su",
+    }
+    return codesToCategory[ roleCode ] || "";
+}

package/package.json

@@ -1,66 +1,28 @@
 {
   "name": "@carecard/jwt-read",
-  "version": "1.0.5",
-  "private": false,
-  "description": "Jwt read functions",
-  "license": "ISC",
-  "author": "PK Singh",
+  "version": "3.0.1",
   "repository": {
     "type": "git",
-    "url": "git+https:github.com/CareCard-ca/pkg-jwt-read.git"
+    "url": "https://github.com/CareCard-ca/pkg-jwt-read.git"
+  },
+  "description": "Jwt read functions",
+  "main": "index.js",
+  "scripts": {
+    "test": "export NODE_ENV=test && mocha --watch --recursive"
   },
   "keywords": [
     "auth",
     "utility",
     "cryptology"
   ],
-  "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/esm/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js",
-      "types": "./dist/esm/index.d.ts"
-    },
-    "./types": {
-      "import": "./dist/esm/types.d.ts",
-      "require": "./dist/cjs/types.d.ts",
-      "types": "./dist/esm/types.d.ts"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "npm run build:esm && npm run build:cjs",
-    "build:esm": "tsc -p tsconfig.esm.json",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "test": "NODE_NO_WARNINGS=1 jest --coverage",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "lint": "eslint",
-    "prepare": "husky"
-  },
+  "author": "CareCard team",
+  "license": "ISC",
   "devDependencies": {
-    "@types/express": "5.0.6",
-    "@types/jest": "30.0.0",
-    "eslint": "9.39.2",
-    "husky": "9.1.7",
-    "jest": "30.2.0",
-    "prettier": "3.7.4",
-    "ts-jest": "29.4.6",
-    "typescript": "5.9.3",
-    "typescript-eslint": "8.50.1"
+    "mocha": "11.7.5"
   },
   "dependencies": {
-    "@carecard/auth-util": "1.0.1",
-    "@carecard/common-util": "1.0.1",
-    "@carecard/validate": "1.0.1",
-    "express": "5.2.1"
+    "@carecard/auth-util": "3.0.1",
+    "@carecard/common-util": "2.0.2",
+    "@carecard/validate": "2.2.12"
   }
 }

package/readme.md

@@ -7,7 +7,7 @@ This is a collection of jwt reading functions.
 ### Main functions
 
 ```js
-const jwtReader = require( '@carecard/jwt-read' );
+const jwtReader = require( '@chatpta/jwt-read' );
 ```
 
 Read jwt
@@ -22,9 +22,11 @@ Following the above ```req.jwt``` contains
 ```js
 {
     header: {
-    alg: ''
+    alg:...
     }
+,
     payload: {
+    ...
     }
 }
 ```

package/dist/cjs/index.d.ts

@@ -1,3 +0,0 @@
-export * from './jwtLib';
-export * from './jwtRoles';
-export * from './types';

package/dist/cjs/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./jwtLib"), exports);
-__exportStar(require("./jwtRoles"), exports);
-__exportStar(require("./types"), exports);

package/dist/cjs/jwtLib.d.ts

@@ -1,38 +0,0 @@
-import type { Response, NextFunction } from 'express';
-import { RequestWithJWToken, Role } from './types';
-export declare function jwtClientId(req: RequestWithJWToken): string | undefined;
-export declare function visitorClientId(req: RequestWithJWToken): string | undefined;
-export declare function doesJwtUserHasRole(req: RequestWithJWToken, userRole: Role): boolean | undefined;
-export declare function throwError(customErrorFunction?: any): void;
-export declare function isJwtExpired(req: RequestWithJWToken, jwtValiditySeconds: number): boolean;
-export declare function jwtAgeInMilliseconds(req: RequestWithJWToken): number;
-export declare function validateAndExtractJwtObject(req: RequestWithJWToken, publicKey: string, customErrorFunction?: any): Promise<any>;
-export declare function validateAndExtractWebToken(req: RequestWithJWToken, publicKey: string, headerName: string, customErrorFunction?: any): Promise<any>;
-export declare function validateAndExtractJwtObjectNoThrow(req: RequestWithJWToken, publicKey: string): Promise<any>;
-export declare function validateAndExtractWebTokenObjectNoThrow(req: RequestWithJWToken, publicKey: string, headerName: string): Promise<any>;
-export declare function validateAndExtractVisitorObjectNoThrow(req: RequestWithJWToken, publicKey: string): Promise<any>;
-export declare function verifyJwtAndRole(role: Role, publicKey: string, customErrorFunction?: any): (req: RequestWithJWToken, res: Response, next: NextFunction) => Promise<any>;
-export declare function verifyJwt(publicKey: string, customErrorFunction?: any): (req: RequestWithJWToken, res: Response, next: NextFunction) => Promise<any>;
-export declare function verifyWebToken(publicKey: string, headerName: string, customErrorFunction?: any): (req: RequestWithJWToken, res: Response, next: NextFunction) => Promise<any>;
-export declare function verifyJwtNoThrow(publicKey: string): (req: RequestWithJWToken, res: Response, next: NextFunction) => Promise<void>;
-export declare function verifyWebTokenNoThrow(publicKey: string, headerName: string): (req: RequestWithJWToken, res: Response, next: NextFunction) => Promise<void>;
-export declare function verifyVisitorNoThrow(publicKey: string): (req: RequestWithJWToken, res: Response, next: NextFunction) => Promise<void>;
-export declare function throwUsedTokenError(): void;
-/*********************
- * Private functions *
- *********************/
-export declare function _isLoginRequired(hasRequiredRole: boolean | undefined, customErrorFunction?: any): void;
-export declare function _extractJwtObject(req: RequestWithJWToken, jwt: string, customErrorFunction?: any): Promise<any>;
-export declare function _extractJwtObjectNoThrow(req: RequestWithJWToken, jwt: string): Promise<any>;
-export declare function _extractVisitorObjectNoThrow(req: RequestWithJWToken, jwt: string): Promise<any>;
-export declare function _isJwtSignatureValid(jwt: string, publicKey: string, customErrorFunction?: any): Promise<any>;
-export declare function _isJwtSignatureValidNoThrow(jwt: string | null, publicKey: string): Promise<any>;
-export declare function _validateJwt(req: RequestWithJWToken, customErrorFunction?: any): Promise<any>;
-export declare function _validateWebToken(req: RequestWithJWToken, headerName: string, customErrorFunction?: any): Promise<any>;
-export declare function _validateJwtNoThrow(req: RequestWithJWToken): string | null;
-export declare function _validateWebTokenNoThrow(req: RequestWithJWToken, headerName: string): string | null;
-export declare function _validateVisitorNoThrow(req: RequestWithJWToken): string | null;
-export declare function _extractJwt(jwtRaw: string | undefined, customErrorFunction?: (msg?: string) => never | void): string | null;
-export declare function _extractWebToken(jwtRaw: string | undefined, customErrorFunction?: any): string | null;
-export declare function _extractJwtNoThrow(jwtRaw: string): string | null;
-export declare function _extractWebTokenNoThrow(jwtRaw: string): string | null;