jsonauthtoken 1.0.1 → 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+declare function jat(): {
+    create: (keys: KeysType, headers?: HeaderForCreate, payloads?: any) => string;
+    verify: (encryptedToken: string, keys: KeysType) => HeaderAndPlayload;
+};
+export default jat;

package/dist/index.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const encoading_lib_1 = __importDefault(require("./lib/encoading.lib"));
+const decoading_lib_1 = __importDefault(require("./lib/decoading.lib"));
+const signature_lib_1 = __importDefault(require("./lib/signature.lib"));
+const encryption_lib_1 = __importDefault(require("./lib/encryption.lib"));
+const decryption_lib_1 = __importDefault(require("./lib/decryption.lib"));
+const functions_lib_1 = require("./lib/functions.lib");
+const algorithms = ['sha256', 'sha384', 'sha512'];
+function jat() {
+    const create = (keys, headers = {}, payloads = {}) => {
+        let { signKey, encKey } = keys;
+        if (!signKey)
+            throw new Error("please provide signkey");
+        if (!encKey)
+            throw new Error("please provide encKey");
+        let exp;
+        if (headers.expiresAt)
+            exp = (0, functions_lib_1.parseExpiration)(headers.expiresAt);
+        else
+            throw new Error("please provide token expire");
+        let algo = (0, functions_lib_1.algoMatching)(algorithms, 'sha512', headers.algorithm);
+        let header = (0, encoading_lib_1.default)({
+            token: 'JAT',
+            algorithm: algo,
+            createAt: Math.floor(Date.now() / 1000),
+            expiresAt: exp,
+        });
+        if (typeof (payloads) != 'object')
+            throw new Error("payload should be Object");
+        let payload = (0, encoading_lib_1.default)(payloads);
+        let sign = (0, signature_lib_1.default)().createSign(algo, signKey, header, payload);
+        let token = header + '.' + payload + '.' + sign;
+        let encryptedToken = (0, encryption_lib_1.default)(encKey, token);
+        return encryptedToken;
+    };
+    const verify = (encryptedToken, keys) => {
+        let token = '';
+        let header;
+        let payload = '';
+        let { signKey, encKey } = keys;
+        if (!signKey)
+            throw new Error("please provide signkey");
+        if (!encKey)
+            throw new Error("please provide encKey");
+        try {
+            token = (0, decryption_lib_1.default)(encryptedToken, encKey);
+        }
+        catch (error) {
+            throw new Error('unable to decrypt token');
+        }
+        const [encodedHeader, encodedPayload, sign] = token.split('.');
+        let isSignVerified = (0, signature_lib_1.default)().verifySign({ encodedHeader, encodedPayload, sign }, signKey);
+        if (isSignVerified === false) {
+            throw new Error('Invalid signature');
+        }
+        header = (0, decoading_lib_1.default)(encodedHeader);
+        if ((0, functions_lib_1.isExpired)(header.expiresAt))
+            throw new Error('token is expired');
+        payload = (0, decoading_lib_1.default)(encodedPayload);
+        return { header, payload };
+    };
+    return { create, verify };
+}
+exports.default = jat;

package/dist/lib/decoading.lib.d.ts

@@ -0,0 +1,2 @@
+declare const decoading: (str: string) => any;
+export default decoading;

package/dist/lib/decoading.lib.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const decoading = (str) => {
+    const base64 = str.replace(/-/g, '+').replace(/_/g, '/');
+    const padding = '='.repeat((4 - base64.length % 4) % 4);
+    const decoded = Buffer.from(base64 + padding, 'base64').toString('utf8');
+    return JSON.parse(decoded);
+};
+exports.default = decoading;

package/dist/lib/decryption.lib.d.ts

@@ -0,0 +1,2 @@
+declare function decryption(encryptedToken: string, password: string): string;
+export default decryption;

package/dist/lib/decryption.lib.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+function decryption(encryptedToken, password) {
+    const parts = encryptedToken.split(':');
+    const iv = Buffer.from(parts.shift(), 'hex');
+    const encryptedTokenBuffer = Buffer.from(parts.join(':'), 'hex');
+    const key = crypto_1.default.scryptSync(password, 'salt', 32);
+    const decipher = crypto_1.default.createDecipheriv('aes-256-cbc', key, iv);
+    let decrypted = decipher.update(encryptedTokenBuffer, null, 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+}
+exports.default = decryption;

package/dist/lib/encoading.lib.d.ts

@@ -0,0 +1,2 @@
+declare function encoading(data: any): string;
+export default encoading;

package/{lib → dist/lib}/encoading.lib.js

@@ -1,7 +1,8 @@
-function encoading(data) {
-    const json = JSON.stringify(data);
-    const base64 = Buffer.from(json).toString('base64');
-    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-  }
-
-export default encoading
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function encoading(data) {
+    const json = JSON.stringify(data);
+    const base64 = Buffer.from(json).toString('base64');
+    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+exports.default = encoading;

package/dist/lib/encryption.lib.d.ts

@@ -0,0 +1,2 @@
+declare function encryption(password: string, token: string): string;
+export default encryption;

package/dist/lib/encryption.lib.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+function encryption(password, token) {
+    const iv = crypto_1.default.randomBytes(16);
+    const key = crypto_1.default.scryptSync(password, 'salt', 32);
+    const cipher = crypto_1.default.createCipheriv('aes-256-cbc', key, iv);
+    let encrypted = cipher.update(token, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    return iv.toString('hex') + ':' + encrypted;
+}
+exports.default = encryption;

package/dist/lib/functions.lib.d.ts

@@ -0,0 +1,4 @@
+declare function algoMatching(algorithms: AlgorithmArray, defaultOutput: Algorithm | string, input: string): string;
+declare function parseExpiration(input: string): number;
+declare function isExpired(timeStamp: number): boolean;
+export { algoMatching, parseExpiration, isExpired };

package/dist/lib/functions.lib.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.algoMatching = algoMatching;
+exports.parseExpiration = parseExpiration;
+exports.isExpired = isExpired;
+function algoMatching(algorithms, defaultOutput, input) {
+    if (!defaultOutput)
+        throw new Error('defaultOutput parameter can not be empty');
+    let defaultAlgorithm = defaultOutput;
+    for (let i in algorithms) {
+        if (algorithms[i] === input)
+            defaultAlgorithm = algorithms[i];
+    }
+    return defaultAlgorithm.toString();
+}
+function parseExpiration(input) {
+    const regex = /^(\d+)([mhdMHDyY]|MIN)$/;
+    const match = input.match(regex);
+    if (!match) {
+        throw new Error('Invalid format. Use formats like 1M, 1Y, 1D, 1MIN.');
+    }
+    const amount = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    let seconds;
+    switch (unit) {
+        case 'y':
+            seconds = amount * 365 * 24 * 60 * 60;
+            break;
+        case 'm':
+            seconds = amount * 30 * 24 * 60 * 60;
+            break;
+        case 'd':
+            seconds = amount * 24 * 60 * 60;
+            break;
+        case 'h':
+            seconds = amount * 60 * 60;
+            break;
+        case 'min':
+            seconds = amount * 60;
+            break;
+        default:
+            throw new Error('Unsupported time unit. Use M, Y, D, H, or MIN.');
+    }
+    return Math.floor(Date.now() / 1000) + seconds;
+}
+function isExpired(timeStamp) {
+    let currentTime = Math.floor(Date.now() / 1000);
+    if (timeStamp < currentTime) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}

package/dist/lib/signature.lib.d.ts

@@ -0,0 +1,5 @@
+declare const signature: () => {
+    createSign: (algorithm: string, key: string, header: string, payload: string) => string;
+    verifySign: (tokens: DecryptedTokenParts, key: string) => boolean;
+};
+export default signature;

package/dist/lib/signature.lib.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const decoading_lib_1 = __importDefault(require("./decoading.lib"));
+const signature = () => {
+    const createSign = (algorithm, key, header, payload) => {
+        const signature = crypto_1.default
+            .createHmac(algorithm, key)
+            .update(header + '.' + payload)
+            .digest('base64url');
+        return signature;
+    };
+    const verifySign = (tokens, key) => {
+        const header = (0, decoading_lib_1.default)(tokens.encodedHeader);
+        let newSign = createSign(header.algorithm, key, tokens.encodedHeader, tokens.encodedPayload);
+        if (newSign === tokens.sign)
+            return true;
+        else
+            return false;
+    };
+    return { createSign, verifySign };
+};
+exports.default = signature;

package/package.json

@@ -1,18 +1,26 @@
 {
   "name": "jsonauthtoken",
-  "version": "1.0.1",
-  "description": "jsonauthtoken is a JavaScript library to secure authentication.",
-  "main": "index.js",
-  "type": "module",
+  "version": "2.0.0",
+  "description": "jsonauthtoken is a JavaScript/TypeScript library to secure authentication.",
+  "main": "dist/index.js",
   "repository": {
     "type": "git",
     "url": "https://github.com/iamAyanBiswas/jsonauthtoken"
   },
   "scripts": {
-    "test": "node index.js"
+    "test": "node dist/index.js",
+    "start": "tsc && node dist/index.js"
   },
   "author": "Ayan Biswas",
   "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/iamAyanBiswas/jsonauthtoken/issues"
+  },
+  "homepage": "https://github.com/iamAyanBiswas/jsonauthtoken#readme",
+  "devDependencies": {
+    "@types/node": "^22.9.0",
+    "typescript": "^5.6.3"
+  },
   "keywords": [
     "jat",
     "jwt",
@@ -24,4 +32,4 @@
     "sha384",
     "sha512"
   ]
-}
+}

package/types.d.ts

@@ -0,0 +1,43 @@
+declare global {
+    export type Algorithm = 'sha256' | 'sha384' | 'sha512';
+    export type AlgorithmArray = ['sha256', 'sha384', 'sha512']
+
+    //type for keys input 
+    interface KeysType {
+        signKey: string;
+        encKey: string;
+    }
+
+    //type for header at create fn  
+    interface HeaderForCreate {
+        expiresAt?: string;
+        algorithm?: Algorithm;
+    }
+
+    //type for header at create fn 
+    interface HeaderForVerify {
+        expiresAt?: string;
+        algorithm?: Algorithm;
+    }
+
+    //
+    interface DecryptedTokenParts {
+        encodedHeader: string;
+        encodedPayload: string;
+        sign: string
+    }
+
+    interface TokenHeaders {
+        token: 'JAT';
+        algorithm: string;
+        createAt: number;
+        expiresAt: number;
+    }
+
+    interface HeaderAndPlayload{
+        header:TokenHeaders;
+        payload:any
+    }
+}
+
+export { };

package/index.js

@@ -1,84 +0,0 @@
-import encoading from './lib/encoading.lib.js'
-import decoading from './lib/decoading.lib.js'
-import signature from './lib/signature.lib.js'
-import encryption from './lib/encryption.lib.js'
-import decryption from './lib/decryption.lib.js'
-import { algoMatching, parseExpiration, isExpired } from './lib/functions.lib.js'
-
-function jat() {
-
-
-    const algorithms = ['sha256', 'sha384', 'sha512']
-
-    /////////////////////---------------  create token  ---------------------/////////////////////////
-    const create = (keys, headers = {}, payloads = {}) => {
-
-        let {signKey, encKey} = keys
-        if(!signKey) throw new Error("please provide signkey");
-        if(!encKey) throw new Error("please provide encKey");
-        
-
-        let exp = ''
-        if (headers.expiresAt) exp = parseExpiration(headers.expiresAt)
-        else throw new Error("please provide token expire")
-
-        let algo = algoMatching(algorithms, 'sha512', headers.algo)
-
-        let header = encoading({
-            token: 'JAT',
-            algorithm: algo,
-            createAt: Math.floor(Date.now() / 1000),
-            expiresAt: exp,
-        })
-
-        if (typeof (payloads) != 'object') throw new Error("payload should be Object");
-        let payload = encoading(payloads)
-
-        let sign = signature().createSign(algo, signKey, header, payload)
-
-        let token = header + '.' + payload + '.' + sign
-        let encryptedToken = encryption(encKey, token)
-        return encryptedToken
-    }
-
-
-    /////////////////////---------------  verify token  ---------------------/////////////////////////
-    const verify = (encryptedToken, keys) => {
-        let token = ''
-        let header = ''
-        let payload = ''
-
-        let {signKey, encKey} = keys
-        if(!signKey) throw new Error("please provide signkey");
-        if(!encKey) throw new Error("please provide encKey");
-
-        //decrypt token
-        try {
-            token = decryption(encryptedToken, encKey)
-        } catch (error) {
-            throw new Error('unable to decrypt token')
-        }
-
-        //verify token signature
-        let isSignVerified = signature().verifySign(token, signKey)
-        if (isSignVerified === false) {
-            throw new Error('Invalid signature')
-        }
-
-        //
-        const [encodedHeader, encodedPayload, sign] = token.split('.');
-
-        header = decoading(encodedHeader)
-        if(isExpired(header.expiresAt)) throw new Error('token is expired')
-
-        payload = decoading(encodedPayload)
-
-        return {header,payload}
-    }
-    return { create, verify }
-}
-
-
-
-
-export default jat

package/lib/decoading.lib.js

@@ -1,14 +0,0 @@
-const decoading = (str) => {
-   // Replace URL-safe characters with standard Base64 characters
-  const base64 = str.replace(/-/g, '+').replace(/_/g, '/');
-
-  // Add padding if necessary
-  const padding = '='.repeat((4 - base64.length % 4) % 4);
-  
-  // Decode the Base64 string
-  const decoded = Buffer.from(base64 + padding, 'base64').toString('utf8');
-  
-  return JSON.parse(decoded);
-  };
-
-export default decoading

package/lib/decryption.lib.js

@@ -1,18 +0,0 @@
-import exp from 'constants';
-import crypto from 'crypto'
-
-function decryption(encryptedToken, password) {
-    const parts = encryptedToken.split(':');
-    const iv = Buffer.from(parts.shift(), 'hex'); // Get the IV
-    const encryptedTokenBuffer = Buffer.from(parts.join(':'), 'hex');
-    const key = crypto.scryptSync(password, 'salt', 32);
-    
-    const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
-    
-    let decrypted = decipher.update(encryptedTokenBuffer, 'binary', 'utf8');
-    decrypted += decipher.final('utf8');
-    
-    return decrypted;
-    
-}
-export default decryption

package/lib/encryption.lib.js

@@ -1,15 +0,0 @@
-import crypto from 'crypto'
-
-function encryption(password,token){
-    const iv = crypto.randomBytes(16); // Initialization vector
-    const key = crypto.scryptSync(password, 'salt', 32); // Key derivation
-    const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
-    
-    let encrypted = cipher.update(token, 'utf8', 'hex');
-    encrypted += cipher.final('hex');
-    
-    // Return the IV and encrypted text
-    return iv.toString('hex') + ':' + encrypted;
-}
-
-export default encryption

package/lib/functions.lib.js

@@ -1,66 +0,0 @@
-function algoMatching(algorithms, defaultOutput, input) {
-
-    //check defaultOutput parameter
-    if (!defaultOutput) throw new Error('defaultOutput parameter can not be empty')
-
-    //find the correct algorithm name is given as 'input' or not , if is't return defaultOutput
-    for (let i in algorithms) {
-        if (String(algorithms[i]) === String(input)) defaultOutput = algorithms[i]
-    }
-
-    return defaultOutput
-}
-
-
-function parseExpiration(input) {
-    const regex = /^(\d+)([mhdMHDyY]|MIN)$/; // Regex to match number + unit
-    const match = input.match(regex);
-
-    if (!match) {
-        throw new Error('Invalid format. Use formats like 1M, 1Y, 1D, 1MIN.');
-    }
-
-    const amount = parseInt(match[1], 10);
-    const unit = match[2].toLowerCase(); // Normalize to lowercase
-
-    let seconds;
-
-    switch (unit) {
-        case 'y':
-            seconds = amount * 365 * 24 * 60 * 60; // Years to seconds
-            break;
-        case 'm':
-            seconds = amount * 30 * 24 * 60 * 60; // Months to seconds (approximation)
-            break;
-        case 'd':
-            seconds = amount * 24 * 60 * 60; // Days to seconds
-            break;
-        case 'h':
-            seconds = amount * 60 * 60; // Hours to seconds
-            break;
-        case 'min':
-            seconds = amount * 60; // Minutes to seconds
-            break;
-        default:
-            throw new Error('Unsupported time unit. Use M, Y, D, H, or MIN.');
-    }
-
-
-    return Math.floor(Date.now() / 1000) + seconds; // Current time + expiration time
-}
-
-
-function isExpired(timeStamp) {
-    let currentTime = Math.floor(Date.now() / 1000)
-    if (timeStamp < currentTime) {
-        return true
-    }
-    else {
-        return false
-    }
-}
-
-
-
-
-export { algoMatching, parseExpiration, isExpired }

package/lib/signature.lib.js

@@ -1,26 +0,0 @@
-import crypto from 'crypto'
-import decoading from './decoading.lib.js';
-
-const signature = () => {
-
-    const createSign = (algorithm, key, header, payload) => {
-        const signature = crypto
-            .createHmac(algorithm, key)
-            .update(header + '.' + payload)
-            .digest('base64url');
-        return signature
-    }
-
-    const verifySign = (token,key) => {
-        const [encodedHeader, encodedPayload, signature] = token.split('.');
-        const header= decoading(encodedHeader)
-
-        let newSign=createSign(header.algorithm, key, encodedHeader, encodedPayload)
-
-        if(newSign == signature) return true
-        else return false
-    }
-    return { createSign, verifySign }
-}
-
-export default signature