jsonauthtoken 1.0.1 → 3.0.0

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+declare class JATClass<R extends Runtime = Runtime> {
+    private runtime;
+    private dev;
+    private crypto;
+    constructor(config?: JATConfig<R>);
+    create(header: CreateTokenConfig<R>, payload: any): Promise<string>;
+    verify<T>(token: string, key: string): Promise<T>;
+}
+export declare const JAT: <R extends Runtime = Runtime>(config?: JATConfig<R>) => JATClass<R>;
+export declare const getSupportedAlgorithm: () => Record<Runtime, AlgorithmDetails[]>;
+export declare const P2KG: {
+    generateKeyPair: (options?: {
+        runtime?: Runtime;
+        dev?: boolean;
+    }) => Promise<GenerateKeyPair>;
+    generatePublicKey: (privateKeyPem: string, options?: {
+        runtime?: Runtime;
+        dev?: boolean;
+    }) => Promise<string>;
+};
+declare const jsonauthtoken: {
+    JAT: <R extends Runtime = Runtime>(config?: JATConfig<R>) => JATClass<R>;
+    P2KG: {
+        generateKeyPair: (options?: {
+            runtime?: Runtime;
+            dev?: boolean;
+        }) => Promise<GenerateKeyPair>;
+        generatePublicKey: (privateKeyPem: string, options?: {
+            runtime?: Runtime;
+            dev?: boolean;
+        }) => Promise<string>;
+    };
+};
+export default jsonauthtoken;

package/dist/index.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.P2KG = exports.getSupportedAlgorithm = exports.JAT = void 0;
+const name_config_1 = require("./config/name.config");
+const runtime_config_1 = require("./config/runtime.config");
+const algo_config_1 = require("./config/algo.config");
+const functions_lib_1 = require("./lib/functions.lib");
+const timeformat_1 = require("./lib/timeformat");
+const crypto_1 = require("./crypto/crypto");
+class JATClass {
+    runtime;
+    dev = false;
+    crypto = new crypto_1.Crypto();
+    constructor(config) {
+        try {
+            if (config && config.dev == true)
+                this.dev = true;
+            if (config && config.runtime) {
+                if (!name_config_1.RUNTIME.includes(config.runtime)) {
+                    throw new Error("Unsupported runtime");
+                }
+                this.runtime = config.runtime;
+            }
+            else {
+                this.runtime = (0, runtime_config_1.detectRuntime)();
+            }
+            (0, functions_lib_1.print)({ dev: this.dev }, 'Current Runtime: ', this.runtime);
+        }
+        catch (error) {
+            (0, functions_lib_1.print)({ dev: this.dev, color: 'red' }, error);
+            throw error;
+        }
+    }
+    async create(header, payload) {
+        try {
+            if (!header.key) {
+                throw new Error('key is required to create token');
+            }
+            const key = header.key;
+            const exp = header.exp ? (0, timeformat_1.jatTimeFormatter)(header.exp) : (0, timeformat_1.jatTimeFormatter)('5MIN');
+            const algo = header.algo || (algo_config_1.DEFAULT_ALGORITHM[this.runtime][0].name);
+            return await this.crypto.createToken(this.runtime, algo, key, payload, exp);
+        }
+        catch (error) {
+            (0, functions_lib_1.print)({ dev: this.dev, color: 'red' }, error);
+            throw error;
+        }
+    }
+    async verify(token, key) {
+        try {
+            if (!token) {
+                throw new Error('Token is required to verify token');
+            }
+            if (!key) {
+                throw new Error('key is required to verify token');
+            }
+            const unfilterPayload = await this.crypto.verifyToken(this.runtime, token, key);
+            if ((0, functions_lib_1.isExpired)(unfilterPayload.exp)) {
+                throw new Error('Token expired');
+            }
+            return unfilterPayload.payload;
+        }
+        catch (error) {
+            (0, functions_lib_1.print)({ dev: this.dev, color: 'red' }, error);
+            throw error;
+        }
+    }
+}
+class PrivatePublicKeyGeneration {
+    crypto = new crypto_1.Crypto();
+    async generateKeyPair(runtime, dev) {
+        let finalRuntime = (0, runtime_config_1.detectRuntime)();
+        const development = dev === true ? true : false;
+        try {
+            if (runtime) {
+                if (!name_config_1.RUNTIME.includes(runtime)) {
+                    throw new Error("Unsupported runtime");
+                }
+                finalRuntime = runtime;
+            }
+            const { privateKey, publicKey } = await this.crypto.rsaKeyDrivation(finalRuntime, 'keyPair');
+            (0, functions_lib_1.print)({ dev: development, color: 'green' }, 'Current Runtime: ', finalRuntime);
+            (0, functions_lib_1.print)({ dev: development, color: 'green' }, { privateKey, publicKey });
+            return { privateKey, publicKey };
+        }
+        catch (error) {
+            (0, functions_lib_1.print)({ dev: development, color: 'red' }, error);
+            throw error;
+        }
+    }
+    async generatePublicKey(privateKeyPem, runtime, dev) {
+        let finalRuntime = (0, runtime_config_1.detectRuntime)();
+        const development = dev === true ? true : false;
+        try {
+            if (runtime) {
+                if (!name_config_1.RUNTIME.includes(runtime)) {
+                    throw new Error("Unsupported runtime");
+                }
+                finalRuntime = runtime;
+            }
+            const publicKey = await this.crypto.rsaKeyDrivation(finalRuntime, 'publickey', privateKeyPem);
+            (0, functions_lib_1.print)({ dev: development, color: 'green' }, 'Current Runtime: ', finalRuntime);
+            (0, functions_lib_1.print)({ dev: development, color: 'green' }, publicKey);
+            return publicKey;
+        }
+        catch (error) {
+            (0, functions_lib_1.print)({ dev: development, color: 'red' }, error);
+            throw error;
+        }
+    }
+}
+const p2kgObject = new PrivatePublicKeyGeneration();
+const generateKeyPair = (options) => {
+    const { runtime, dev } = options || {};
+    return p2kgObject.generateKeyPair(runtime, dev);
+};
+const generatePublicKey = (privateKeyPem, options) => {
+    const { runtime, dev } = options || {};
+    return p2kgObject.generatePublicKey(privateKeyPem, runtime, dev);
+};
+const JAT = (config) => new JATClass(config);
+exports.JAT = JAT;
+const getSupportedAlgorithm = () => algo_config_1.SUPPORTED_ALGORITHM;
+exports.getSupportedAlgorithm = getSupportedAlgorithm;
+exports.P2KG = {
+    generateKeyPair: generateKeyPair,
+    generatePublicKey: generatePublicKey
+};
+const jsonauthtoken = {
+    JAT: exports.JAT,
+    P2KG: exports.P2KG
+};
+exports.default = jsonauthtoken;

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/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/functions.lib.d.ts

@@ -0,0 +1,12 @@
+declare function tokenFormatCreate<R extends Runtime = Runtime>(meta: TokenMetaData<R>, encrypted: string): string;
+declare function tokenFormatVerify<R extends Runtime = Runtime>(token: string): {
+    meta: TokenMetaData<R>;
+    encrypted: string;
+};
+declare function isExpired(timeStamp: number): boolean;
+type Color = 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white';
+declare function print({ dev, color }: {
+    dev?: boolean;
+    color?: Color;
+}, ...args: unknown[]): void;
+export { isExpired, tokenFormatCreate, tokenFormatVerify, print };

package/dist/lib/functions.lib.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExpired = isExpired;
+exports.tokenFormatCreate = tokenFormatCreate;
+exports.tokenFormatVerify = tokenFormatVerify;
+exports.print = print;
+const algo_config_1 = require("../config/algo.config");
+const encoading_lib_1 = __importDefault(require("./encoading.lib"));
+const decoading_lib_1 = __importDefault(require("./decoading.lib"));
+const name_config_1 = require("../config/name.config");
+function tokenFormatCreate(meta, encrypted) {
+    return `${(0, encoading_lib_1.default)(meta)}:${encrypted}`;
+}
+function tokenFormatVerify(token) {
+    const index = token.indexOf(":");
+    if (index === -1) {
+        throw new Error("Invalid token format");
+    }
+    const metaPart = token.substring(0, index);
+    const encryptedPart = token.substring(index + 1);
+    const meta = (0, decoading_lib_1.default)(metaPart);
+    if (!meta) {
+        throw new Error("Invalid token format");
+    }
+    const algorithm = algo_config_1.SUPPORTED_ALGORITHM[meta.runtime]?.find(e => e.name === meta.algo);
+    if (!algorithm) {
+        throw new Error("Invalid token format");
+    }
+    if (algorithm.type !== meta.type) {
+        throw new Error("Invalid token format");
+    }
+    if (meta.type === 'asymmetric') {
+        if (!meta.encryptedKey) {
+            throw new Error("Invalid token format");
+        }
+    }
+    if (!meta.iv) {
+        throw new Error("Invalid token format");
+    }
+    if (!name_config_1.RUNTIME.includes(meta.runtime)) {
+        throw new Error("Invalid token format");
+    }
+    if (meta.runtime === 'node') {
+        if (!meta.tag) {
+            throw new Error("Invalid token format");
+        }
+    }
+    if (!meta.v) {
+        throw new Error("Invalid token format");
+    }
+    return { meta, encrypted: encryptedPart };
+}
+function isExpired(timeStamp) {
+    let currentTime = Math.floor(Date.now() / 1000);
+    if (timeStamp < currentTime) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function print({ dev = false, color = 'green' }, ...args) {
+    if (!dev)
+        return;
+    const colors = {
+        red: '\x1b[31m',
+        green: '\x1b[32m',
+        yellow: '\x1b[33m',
+        blue: '\x1b[34m',
+        magenta: '\x1b[35m',
+        cyan: '\x1b[36m',
+        white: '\x1b[37m',
+        reset: '\x1b[0m',
+    };
+    if (typeof window !== 'undefined') {
+        console.log(`%c[jsonauthtoken]`, `color:${color}`, ...args);
+    }
+    else {
+        const colorCode = colors[color] ?? colors.green;
+        console.log(`${colorCode}[jsonauthtoken]`, ...args, '\x1b[0m');
+    }
+}

package/dist/lib/timeformat.d.ts

@@ -0,0 +1 @@
+export declare function jatTimeFormatter(input: JATTime): number;

package/dist/lib/timeformat.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jatTimeFormatter = jatTimeFormatter;
+function jatTimeFormatter(input) {
+    if (typeof input === 'number') {
+        if (input <= 0) {
+            throw new Error('Expiration time must be greater than zero.');
+        }
+        return Math.floor(Date.now() / 1000) + input;
+    }
+    const regex = /^(\d+)(S|MIN|H|D|M|Y)$/i;
+    const match = input.match(regex);
+    if (!match) {
+        throw new Error('Invalid format. Use number or formats like 1S, 1MIN, 1H, 1D, 1M, or 1Y.');
+    }
+    const amount = parseInt(match[1], 10);
+    const unit = match[2].toUpperCase();
+    let seconds;
+    switch (unit) {
+        case 'S':
+            seconds = amount;
+            break;
+        case 'MIN':
+            seconds = amount * 60;
+            break;
+        case 'H':
+            seconds = amount * 60 * 60;
+            break;
+        case 'D':
+            seconds = amount * 24 * 60 * 60;
+            break;
+        case 'M':
+            seconds = amount * 30 * 24 * 60 * 60;
+            break;
+        case 'Y':
+            seconds = amount * 365 * 24 * 60 * 60;
+            break;
+        default:
+            throw new Error(`Unsupported time unit: ${unit}`);
+    }
+    return Math.floor(Date.now() / 1000) + seconds;
+}

package/package.json

@@ -1,27 +1,32 @@
 {
   "name": "jsonauthtoken",
-  "version": "1.0.1",
-  "description": "jsonauthtoken is a JavaScript library to secure authentication.",
-  "main": "index.js",
-  "type": "module",
+  "version": "3.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"
+    "url": "git+https://github.com/iamAyanBiswas/jsonauthtoken.git"
   },
   "scripts": {
-    "test": "node index.js"
+    "build": "tsc",
+    "dev": "nodemon --watch src --ext ts --exec \"npm run build && node dist/test.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",
     "jsonauthtoken",
     "jsonwebtoken",
     "auth",
-    "authentication",
-    "sha256",
-    "sha384",
-    "sha512"
+    "authentication"
   ]
 }

package/types.d.ts

@@ -0,0 +1,67 @@
+import { RUNTIME } from "./src/config/name.config";
+
+declare global {
+
+    type TimeUnit = 'S' | 'MIN' | 'H' | 'D' | 'M' | 'Y';
+    type ExpirationString = `${number}${TimeUnit}` | `${number}${Lowercase<TimeUnit>}`;
+    type JATTime = number | ExpirationString;
+
+    interface GenerateKeyPair {
+        privateKey: string
+        publicKey: string
+    }
+
+    type Runtime = 'node' | 'web' | 'edge';
+    type EncryptionAlgorithmType = 'symmetric' | 'asymmetric';
+
+    interface AlgorithmDetails {
+        name: string;
+        value: string
+        type: EncryptionAlgorithmType;
+    }
+
+    interface RuntimeWiseAlgorithmMap {
+        node: 'AES-256-GCM' | 'RSA+A256GCM'
+        edge: 'AES-GCM' | 'RSA+AES-GCM'
+        web: 'AES-GCM' | 'RSA+AES-GCM'
+    }
+
+    type RuntimeWiseAlgorithm<R extends Runtime> = RuntimeWiseAlgorithmMap[R];
+
+    interface JATConfig<R extends Runtime = Runtime> {
+        runtime?: R
+        dev?: boolean
+    }
+
+    interface CreateTokenConfig<R extends Runtime> {
+        key: string
+        exp?: JATTime
+        algo?: RuntimeWiseAlgorithm<R>
+    }
+
+    interface BaseTokenMetaData<R extends Runtime> {
+        runtime: Runtime;
+        algo: RuntimeWiseAlgorithm<R>;
+        v: string;
+        iv: string;
+    }
+
+ type TokenMetaData<R extends Runtime> =
+  | (BaseTokenMetaData<R> & {
+      runtime: 'node';
+      tag: string;
+    } & (
+      | { type: 'symmetric'; encryptedKey?: never }
+      | { type: 'asymmetric'; encryptedKey: string }
+    ))
+  | (BaseTokenMetaData<R> & {
+      runtime: 'web' | 'edge';
+      tag?: never;
+    } & (
+      | { type: 'symmetric'; encryptedKey?: never }
+      | { type: 'asymmetric'; encryptedKey: string }
+    ));
+
+}
+
+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 }