jsonauthtoken 3.0.2 → 3.0.4-beta-1

package/types.d.ts

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

package/dist/config/algo.config.d.ts

@@ -1,2 +0,0 @@
-export declare const SUPPORTED_ALGORITHM: Record<Runtime, AlgorithmDetails[]>;
-export declare const DEFAULT_ALGORITHM: Record<Runtime, AlgorithmDetails[]>;

package/dist/config/algo.config.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_ALGORITHM = exports.SUPPORTED_ALGORITHM = void 0;
-exports.SUPPORTED_ALGORITHM = {
-    node: [
-        { name: 'AES-256-GCM', value: 'aes-256-gcm', type: 'symmetric' },
-        { name: 'RSA+A256GCM', value: 'rsa+a256gcm', type: 'asymmetric' },
-    ],
-    web: [
-        { name: 'AES-GCM', value: 'AES-GCM', type: 'symmetric' },
-        { name: 'RSA+AES-GCM', value: 'RSA+AES-GCM', type: 'asymmetric' }
-    ],
-    edge: [
-        { name: 'AES-GCM', value: 'AES-GCM', type: 'symmetric' },
-        { name: 'RSA+AES-GCM', value: 'RSA+AES-GCM', type: 'asymmetric' }
-    ]
-};
-exports.DEFAULT_ALGORITHM = {
-    node: [
-        { name: 'AES-256-GCM', value: 'aes-256-gcm', type: 'symmetric' },
-    ],
-    web: [
-        { name: 'AES-GCM', value: 'AES-GCM', type: 'symmetric' },
-    ],
-    edge: [
-        { name: 'AES-GCM', value: 'AES-GCM', type: 'symmetric' },
-    ]
-};

package/dist/config/name.config.d.ts

@@ -1 +0,0 @@
-export declare const RUNTIME: Runtime[];

package/dist/config/name.config.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RUNTIME = void 0;
-exports.RUNTIME = ['node', 'edge', 'web'];

package/dist/config/runtime.config.d.ts

@@ -1 +0,0 @@
-export declare function detectRuntime(): Runtime;

package/dist/config/runtime.config.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectRuntime = detectRuntime;
-function detectRuntime() {
-    if (typeof process !== 'undefined' && process.versions?.node) {
-        return 'node';
-    }
-    if (typeof window !== 'undefined' && window.crypto?.subtle) {
-        return 'web';
-    }
-    if (typeof globalThis !== 'undefined' && globalThis.crypto?.subtle) {
-        return 'edge';
-    }
-    return 'node';
-}

package/dist/index.d.ts

@@ -1,34 +0,0 @@
-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

@@ -1,133 +0,0 @@
-"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 runtime_1 = require("./runtime/runtime");
-class JATClass {
-    runtime;
-    dev = false;
-    crypto = new runtime_1.RuntimeCrypto();
-    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 runtime_1.RuntimeCrypto();
-    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

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

package/dist/lib/decoading.lib.js

@@ -1,9 +0,0 @@
-"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

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

package/dist/lib/encoading.lib.js

@@ -1,8 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-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

@@ -1,85 +0,0 @@
-"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

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

package/dist/lib/timeformat.js

@@ -1,42 +0,0 @@
-"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/dist/runtime/node.runtime.d.ts

@@ -1,31 +0,0 @@
-export declare class NodeCrypto {
-    private crypto;
-    private __init;
-    private _encrypt;
-    private _decrypt;
-    private _rsaPublicKeyGeneration;
-    private _rsaPrivatePublicKeyGeneration;
-    encrypt(algo: 'aes-256-gcm', key: string, payload: any, exp: number): Promise<string>;
-    decrypt<T>(algo: 'aes-256-gcm', key: string, encryptedData: {
-        iv: string;
-        encrypted: string;
-        tag: string;
-    }): Promise<{
-        payload: T;
-        exp: number;
-    }>;
-    encryptRSA(payload: any, publicKey: string, exp: number): Promise<string>;
-    decryptRSA<T>(privateKey: string, encryptedKey: string, encryptedData: {
-        iv: string;
-        encrypted: string;
-        tag: string;
-    }): Promise<{
-        payload: T;
-        exp: number;
-    }>;
-    rsaPrivatePublicKeyGeneration(): Promise<{
-        privateKey: string;
-        publicKey: string;
-    }>;
-    rsaPublicKeyGeneration(privateKeyPem: string): Promise<string | Buffer<ArrayBufferLike>>;
-}