@vardario/cognito-client 0.1.6 → 0.1.8

package/lib/cognito-client.d.ts

@@ -1,4 +1,4 @@
-import { SessionStorage } from './session-storage/index.js';
+import { SessionStorage } from "./session-storage/index.js";
 export interface UserAttribute {
     Name: string;
     Value: string;
@@ -23,7 +23,7 @@ export interface OAuth2Props {
     /**
      * Response type.
      */
-    responseType: 'code';
+    responseType: "code";
 }
 export interface CognitoClientProps {
     /**
@@ -85,15 +85,15 @@ export interface Session {
  * Represents the decoded values from a JWT ID token.
  */
 export interface IdToken extends Record<string, string | string[] | number | boolean> {
-    'cognito:username': string;
-    'cognito:groups': string[];
+    "cognito:username": string;
+    "cognito:groups": string[];
     email_verified: boolean;
     email: string;
     iss: string;
     origin_jti: string;
     aud: string;
     event_id: string;
-    token_use: 'id';
+    token_use: "id";
     auth_time: number;
     exp: number;
     iat: number;
@@ -111,7 +111,7 @@ export interface AccessToken extends Record<string, string | string[] | number |
     origin_jti: string;
     scope: string;
     sub: string;
-    token_use: 'access';
+    token_use: "access";
     username: string;
 }
 export interface DecodedTokens {
@@ -157,7 +157,7 @@ export interface AuthenticationResponse {
     AuthenticationResult: AuthenticationResult;
 }
 export interface ChallengeResponse {
-    ChallengeName: 'PASSWORD_VERIFIER';
+    ChallengeName: "PASSWORD_VERIFIER";
     ChallengeParameters: {
         SALT: string;
         SECRET_BLOCK: string;
@@ -175,7 +175,7 @@ export declare class CognitoClient {
     private readonly userPoolClientId;
     private readonly sessionStorage;
     private readonly oAuth?;
-    constructor({ userPoolId, userPoolClientId, endpoint, sessionStorage, oAuth2: oAuth }: CognitoClientProps);
+    constructor({ userPoolId, userPoolClientId, endpoint, sessionStorage, oAuth2: oAuth, }: CognitoClientProps);
     static getDecodedTokenFromSession(session: Session): DecodedTokens;
     private cognitoRequest;
     private static authResultToSession;
@@ -276,7 +276,7 @@ export declare class CognitoClient {
      *
      * @throws {Error}
      */
-    generateOAuthSignInUrl(identityProvider?: CognitoIdentityProvider): string;
+    generateOAuthSignInUrl(identityProvider?: CognitoIdentityProvider): Promise<string>;
     /**
      *
      * Handles Cognito`s OAuth2 code flow after redirection from Cognito`s Hosted UI.

package/lib/cognito-client.js

@@ -1,9 +1,9 @@
-import addSeconds from 'date-fns/addSeconds';
-import { sha256 } from 'hash.js';
-import { BigInteger } from 'jsbn';
-import randomBytes from 'randombytes';
-import { AuthError, AuthException, getAuthError } from './error.js';
-import { calculateSignature, calculateU, decodeJwt, generateA, generateSmallA, getPasswordAuthenticationKey, } from './utils.js';
+import { addSeconds } from "date-fns";
+import hashJs from "hash.js";
+import { BigInteger } from "jsbn";
+import { Buffer } from "buffer";
+import { AuthError, AuthException, getAuthError, } from "./error.js";
+import { calculateSignature, calculateU, decodeJwt, generateA, generateSmallA, getPasswordAuthenticationKey, randomBytes, } from "./utils.js";
 /**
  * List of used and supported Cognito API calls.
  * @see https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_Operations.html for more details
@@ -38,9 +38,9 @@ export var CognitoIdentityProvider;
  * Lightweight AWS Cogito client without any AWS SDK dependencies.
  */
 export class CognitoClient {
-    constructor({ userPoolId, userPoolClientId, endpoint, sessionStorage, oAuth2: oAuth }) {
-        const [cognitoPoolRegion, cognitoPoolName] = userPoolId.split('_');
-        this.cognitoEndpoint = (endpoint || `https://cognito-idp.${cognitoPoolRegion}.amazonaws.com`).replace(/\/$/, '');
+    constructor({ userPoolId, userPoolClientId, endpoint, sessionStorage, oAuth2: oAuth, }) {
+        const [cognitoPoolRegion, cognitoPoolName] = userPoolId.split("_");
+        this.cognitoEndpoint = (endpoint || `https://cognito-idp.${cognitoPoolRegion}.amazonaws.com`).replace(/\/$/, "");
         this.cognitoPoolName = cognitoPoolName;
         this.userPoolClientId = userPoolClientId;
         this.sessionStorage = sessionStorage;
@@ -57,13 +57,14 @@ export class CognitoClient {
     async cognitoRequest(body, serviceTarget) {
         const respondToAuthChallenge = await fetch(this.cognitoEndpoint, {
             headers: {
-                'x-amz-target': `AWSCognitoIdentityProviderService.${serviceTarget}`,
-                'content-type': 'application/x-amz-json-1.1',
+                "x-amz-target": `AWSCognitoIdentityProviderService.${serviceTarget}`,
+                "content-type": "application/x-amz-json-1.1",
             },
-            method: 'POST',
+            method: "POST",
             body: JSON.stringify(body),
         });
-        if (respondToAuthChallenge.status < 200 || respondToAuthChallenge.status > 299) {
+        if (respondToAuthChallenge.status < 200 ||
+            respondToAuthChallenge.status > 299) {
             const errorMessage = (await respondToAuthChallenge.json());
             throw getAuthError(errorMessage);
         }
@@ -87,10 +88,10 @@ export class CognitoClient {
      * @throws {AuthException}
      */
     async authenticateUserSrp(username, password) {
-        const smallA = generateSmallA();
+        const smallA = await generateSmallA();
         const A = generateA(smallA);
         const initiateAuthPayload = {
-            AuthFlow: 'USER_SRP_AUTH',
+            AuthFlow: "USER_SRP_AUTH",
             ClientId: this.userPoolClientId,
             AuthParameters: {
                 USERNAME: username,
@@ -105,7 +106,7 @@ export class CognitoClient {
         const hkdf = getPasswordAuthenticationKey(this.cognitoPoolName, challenge.ChallengeParameters.USER_ID_FOR_SRP, password, B, U, smallA, salt);
         const { signature, timeStamp } = calculateSignature(this.cognitoPoolName, challenge.ChallengeParameters.USER_ID_FOR_SRP, challenge.ChallengeParameters.SECRET_BLOCK, hkdf);
         const respondToAuthChallengePayload = {
-            ChallengeName: 'PASSWORD_VERIFIER',
+            ChallengeName: "PASSWORD_VERIFIER",
             ClientId: this.userPoolClientId,
             ChallengeResponses: {
                 PASSWORD_CLAIM_SECRET_BLOCK: challenge.ChallengeParameters.SECRET_BLOCK,
@@ -131,7 +132,7 @@ export class CognitoClient {
      */
     async authenticateUser(username, password) {
         const initiateAuthPayload = {
-            AuthFlow: 'USER_PASSWORD_AUTH',
+            AuthFlow: "USER_PASSWORD_AUTH",
             ClientId: this.userPoolClientId,
             AuthParameters: {
                 USERNAME: username,
@@ -146,7 +147,7 @@ export class CognitoClient {
     }
     async refreshSession(session) {
         const refreshTokenPayload = {
-            AuthFlow: 'REFRESH_TOKEN_AUTH',
+            AuthFlow: "REFRESH_TOKEN_AUTH",
             ClientId: this.userPoolClientId,
             AuthParameters: {
                 REFRESH_TOKEN: session.refreshToken,
@@ -224,7 +225,7 @@ export class CognitoClient {
     async changePassword(currentPassword, newPassword) {
         const session = await this.getSession();
         if (session === undefined) {
-            throw new AuthException('User must be authenticated', AuthError.UserNotAuthenticated);
+            throw new AuthException("User must be authenticated", AuthError.UserNotAuthenticated);
         }
         const changePasswordPayload = {
             PreviousPassword: currentPassword,
@@ -236,7 +237,7 @@ export class CognitoClient {
     async updateUserAttributes(userAttributes) {
         const session = await this.getSession();
         if (session === undefined) {
-            throw new AuthException('User must be authenticated', AuthError.UserNotAuthenticated);
+            throw new AuthException("User must be authenticated", AuthError.UserNotAuthenticated);
         }
         const updateUserAttributesPayload = {
             UserAttributes: userAttributes,
@@ -247,7 +248,7 @@ export class CognitoClient {
     async verifyUserAttribute(attributeName, code) {
         const session = await this.getSession();
         if (session === undefined) {
-            throw new AuthException('User must be authenticated', AuthError.UserNotAuthenticated);
+            throw new AuthException("User must be authenticated", AuthError.UserNotAuthenticated);
         }
         const verifyUserAttributePayload = {
             AttributeName: attributeName,
@@ -264,7 +265,7 @@ export class CognitoClient {
     async signOut() {
         const session = await this.getSession();
         if (session === undefined) {
-            throw new AuthException('User must be authenticated', AuthError.UserNotAuthenticated);
+            throw new AuthException("User must be authenticated", AuthError.UserNotAuthenticated);
         }
         const revokeTokenPayload = {
             Token: session.refreshToken,
@@ -324,26 +325,27 @@ export class CognitoClient {
      *
      * @throws {Error}
      */
-    generateOAuthSignInUrl(identityProvider) {
+    async generateOAuthSignInUrl(identityProvider) {
         if (this.oAuth === undefined) {
-            throw Error('You have to define oAuth options to use generateFederatedSignUrl');
+            throw Error("You have to define oAuth options to use generateFederatedSignUrl");
         }
-        const state = randomBytes(32).toString('hex');
-        const pkce = randomBytes(128).toString('hex');
-        const code_challenge = Buffer.from(sha256().update(pkce).digest())
-            .toString('base64')
-            .replace(/\+/g, '-')
-            .replace(/\//g, '_')
-            .replace(/=+$/, '');
+        const state = (await randomBytes(32)).toString("hex");
+        const pkce = (await randomBytes(128)).toString("hex");
+        const code_challenge = Buffer.from(hashJs.sha256().update(pkce).digest())
+            .toString("base64")
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=+$/, "");
         const queryParams = new URLSearchParams();
-        queryParams.append('redirect_uri', this.oAuth.redirectUrl);
-        queryParams.append('response_type', this.oAuth.responseType);
-        queryParams.append('client_id', this.userPoolClientId);
-        identityProvider && queryParams.append('identity_provider', identityProvider);
-        queryParams.append('scope', this.oAuth.scopes.join(' '));
-        queryParams.append('state', state);
-        queryParams.append('code_challenge', code_challenge);
-        queryParams.append('code_challenge_method', 'S256');
+        queryParams.append("redirect_uri", this.oAuth.redirectUrl);
+        queryParams.append("response_type", this.oAuth.responseType);
+        queryParams.append("client_id", this.userPoolClientId);
+        identityProvider &&
+            queryParams.append("identity_provider", identityProvider);
+        queryParams.append("scope", this.oAuth.scopes.join(" "));
+        queryParams.append("state", state);
+        queryParams.append("code_challenge", code_challenge);
+        queryParams.append("code_challenge_method", "S256");
         this.sessionStorage.setOauthVerificationParams({
             state,
             pkce,
@@ -363,36 +365,36 @@ export class CognitoClient {
      */
     async handleCodeFlow(returnUrl) {
         if (this.oAuth === undefined) {
-            throw Error('You have to define oAuth options to use handleCodeFlow');
+            throw Error("You have to define oAuth options to use handleCodeFlow");
         }
         const url = new URL(returnUrl);
-        const code = url.searchParams.get('code');
-        const state = url.searchParams.get('state');
+        const code = url.searchParams.get("code");
+        const state = url.searchParams.get("state");
         if (code === null || state === null) {
-            throw Error('code or state parameter is missing from return url.');
+            throw Error("code or state parameter is missing from return url.");
         }
         const oAuthVerificationParams = this.sessionStorage.getOauthVerificationParams();
         if (oAuthVerificationParams === undefined) {
-            throw new Error('OAuth verification parameters are missing, did you forgot to call generateOAuthSignInUrl ?');
+            throw new Error("OAuth verification parameters are missing, did you forgot to call generateOAuthSignInUrl ?");
         }
         if (oAuthVerificationParams.state !== state) {
-            throw new Error('state parameter does not match with previous value generated by previous call of generateOAuthSignInUrl .');
+            throw new Error("state parameter does not match with previous value generated by previous call of generateOAuthSignInUrl .");
         }
         const urlParams = new URLSearchParams();
-        urlParams.append('grant_type', 'authorization_code');
-        urlParams.append('code', code);
-        urlParams.append('client_id', this.userPoolClientId);
-        urlParams.append('redirect_uri', this.oAuth.redirectUrl);
-        urlParams.append('code_verifier', oAuthVerificationParams.pkce);
+        urlParams.append("grant_type", "authorization_code");
+        urlParams.append("code", code);
+        urlParams.append("client_id", this.userPoolClientId);
+        urlParams.append("redirect_uri", this.oAuth.redirectUrl);
+        urlParams.append("code_verifier", oAuthVerificationParams.pkce);
         const tokenEndpoint = `${this.oAuth.cognitoDomain}/oauth2/token`;
         const response = await fetch(tokenEndpoint, {
-            method: 'POST',
+            method: "POST",
             headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
+                "Content-Type": "application/x-www-form-urlencoded",
             },
             body: urlParams.toString(),
         });
-        const { access_token, refresh_token, id_token, expires_in, token_type, error } = await response.json();
+        const { access_token, refresh_token, id_token, expires_in, token_type, error, } = await response.json();
         if (error) {
             throw new Error(error);
         }

package/lib/cognito-client.test.js

@@ -76,9 +76,9 @@ describe("Cognito Client", () => {
         expect(cognitoClient.authenticateUser(user.email, user.password)).rejects.toThrow();
         await cognitoClient.authenticateUser(user.email, "newPassword");
     });
-    test("generateOAuthSignInUrl", () => {
-        const _test = (cb, identityProvider) => {
-            const hostedUIUrl = cognitoClient.generateOAuthSignInUrl(identityProvider);
+    test("generateOAuthSignInUrl", async () => {
+        const _test = async (cb, identityProvider) => {
+            const hostedUIUrl = await cognitoClient.generateOAuthSignInUrl(identityProvider);
             const { searchParams } = new URL(hostedUIUrl);
             expect(searchParams.get("redirect_uri")).toBe(oAuth2.redirectUrl);
             expect(searchParams.get("response_type")).toBe(oAuth2.responseType);
@@ -89,10 +89,10 @@ describe("Cognito Client", () => {
             expect(searchParams.get("code_challenge_method")).toBe("S256");
             cb(searchParams);
         };
-        _test((searchParams) => {
+        await _test((searchParams) => {
             expect(searchParams.get("identity_provider")).toBeNull();
         });
-        _test((searchParams) => {
+        await _test((searchParams) => {
             expect(searchParams.get("identity_provider")).toBe(CognitoIdentityProvider.Apple);
         }, CognitoIdentityProvider.Apple);
     });

package/lib/utils.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
-import { BigInteger } from 'jsbn';
+import { BigInteger } from "jsbn";
+import { Buffer } from "buffer";
 export declare function padHex(bigInt: BigInteger): string;
 export declare function hashHexString(str: string): string;
 export declare function hashBuffer(buffer: Buffer): string;
-export declare function generateSmallA(): BigInteger;
+export declare function generateSmallA(): Promise<BigInteger>;
 export declare function generateA(smallA: BigInteger): BigInteger;
 export declare function calculateU(A: BigInteger, B: BigInteger): BigInteger;
 export declare function calculateS(X: BigInteger, B: BigInteger, U: BigInteger, smallA: BigInteger): BigInteger;
@@ -18,3 +19,4 @@ export declare function decodeJwt<T = unknown>(jwt: string): {
     payload: T;
     signature: string;
 };
+export declare function randomBytes(num: number): Promise<Buffer>;

package/lib/utils.js

@@ -1,25 +1,25 @@
-import formatInTimeZone from 'date-fns-tz/formatInTimeZone';
-import { hmac, sha256 } from 'hash.js';
-import { BigInteger } from 'jsbn';
-import randomBytes from 'randombytes';
-const initN = 'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1' +
-    '29024E088A67CC74020BBEA63B139B22514A08798E3404DD' +
-    'EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245' +
-    'E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED' +
-    'EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D' +
-    'C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F' +
-    '83655D23DCA3AD961C62F356208552BB9ED529077096966D' +
-    '670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B' +
-    'E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9' +
-    'DE2BCBF6955817183995497CEA956AE515D2261898FA0510' +
-    '15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64' +
-    'ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7' +
-    'ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B' +
-    'F12FFA06D98A0864D87602733EC86A64521F2B18177B200C' +
-    'BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31' +
-    '43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF';
+import formatInTimeZone from "date-fns-tz/formatInTimeZone";
+import hashJs from "hash.js";
+import { BigInteger } from "jsbn";
+import { Buffer } from "buffer";
+const initN = "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1" +
+    "29024E088A67CC74020BBEA63B139B22514A08798E3404DD" +
+    "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245" +
+    "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED" +
+    "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D" +
+    "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F" +
+    "83655D23DCA3AD961C62F356208552BB9ED529077096966D" +
+    "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B" +
+    "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9" +
+    "DE2BCBF6955817183995497CEA956AE515D2261898FA0510" +
+    "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64" +
+    "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7" +
+    "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B" +
+    "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C" +
+    "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31" +
+    "43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF";
 const N = new BigInteger(initN, 16);
-const g = new BigInteger('2', 16);
+const g = new BigInteger("2", 16);
 const k = new BigInteger(hashHexString(`${padHex(N)}${padHex(g)}`), 16);
 export function padHex(bigInt) {
     const HEX_MSB_REGEX = /^[89a-f]/i;
@@ -29,29 +29,29 @@ export function padHex(bigInt) {
     hexStr = HEX_MSB_REGEX.test(hexStr) ? `00${hexStr}` : hexStr;
     if (isNegative) {
         const invertedNibbles = hexStr
-            .split('')
+            .split("")
             .map((x) => {
             const invertedNibble = ~parseInt(x, 16) & 0xf;
-            return '0123456789ABCDEF'.charAt(invertedNibble);
+            return "0123456789ABCDEF".charAt(invertedNibble);
         })
-            .join('');
+            .join("");
         const flippedBitsBI = new BigInteger(invertedNibbles, 16).add(BigInteger.ONE);
         hexStr = flippedBitsBI.toString(16);
-        if (hexStr.toUpperCase().startsWith('FF8')) {
+        if (hexStr.toUpperCase().startsWith("FF8")) {
             hexStr = hexStr.substring(2);
         }
     }
     return hexStr;
 }
 export function hashHexString(str) {
-    return hashBuffer(Buffer.from(str, 'hex'));
+    return hashBuffer(Buffer.from(str, "hex"));
 }
 export function hashBuffer(buffer) {
-    const hash = sha256().update(buffer).digest('hex');
-    return new Array(64 - hash.length).join('0') + hash;
+    const hash = hashJs.sha256().update(buffer).digest("hex");
+    return new Array(64 - hash.length).join("0") + hash;
 }
-export function generateSmallA() {
-    return new BigInteger(randomBytes(128).toString('hex'), 16);
+export async function generateSmallA() {
+    return new BigInteger((await randomBytes(128)).toString("hex"), 16);
 }
 export function generateA(smallA) {
     const A = g.modPow(smallA, N);
@@ -67,45 +67,59 @@ export function calculateS(X, B, U, smallA) {
 }
 export function calculateHKDF(ikm, salt) {
     const infoBitsBuffer = Buffer.concat([
-        Buffer.from('Caldera Derived Key', 'utf8'),
-        Buffer.from(String.fromCharCode(1), 'utf8'),
+        Buffer.from("Caldera Derived Key", "utf8"),
+        Buffer.from(String.fromCharCode(1), "utf8"),
     ]);
-    const prk = hmac(sha256, salt)
+    const prk = hashJs
+        .hmac(hashJs.sha256, salt)
         .update(ikm)
         .digest();
-    const hmacResult = hmac(sha256, prk)
+    const hmacResult = hashJs
+        .hmac(hashJs.sha256, prk)
         .update(infoBitsBuffer)
         .digest();
     return hmacResult.slice(0, 16);
 }
 export function getPasswordAuthenticationKey(poolName, username, password, B, U, smallA, salt) {
     const usernamePassword = `${poolName}${username}:${password}`;
-    const usernamePasswordHash = hashBuffer(Buffer.from(usernamePassword, 'utf-8'));
+    const usernamePasswordHash = hashBuffer(Buffer.from(usernamePassword, "utf-8"));
     const X = new BigInteger(hashHexString(padHex(salt) + usernamePasswordHash), 16);
     const S = calculateS(X, B, U, smallA);
-    return calculateHKDF(Buffer.from(padHex(S), 'hex'), Buffer.from(padHex(U), 'hex'));
+    return calculateHKDF(Buffer.from(padHex(S), "hex"), Buffer.from(padHex(U), "hex"));
 }
 export function calculateSignature(poolName, userId, secretBlock, hkdf) {
-    const timeStamp = formatInTimeZone(new Date(), 'UTC', "EEE MMM d HH:mm:ss 'UTC' yyyy");
+    const timeStamp = formatInTimeZone(new Date(), "UTC", "EEE MMM d HH:mm:ss 'UTC' yyyy");
     const concatBuffer = Buffer.concat([
-        Buffer.from(poolName, 'utf8'),
-        Buffer.from(userId, 'utf8'),
-        Buffer.from(secretBlock, 'base64'),
-        Buffer.from(timeStamp, 'utf8'),
+        Buffer.from(poolName, "utf8"),
+        Buffer.from(userId, "utf8"),
+        Buffer.from(secretBlock, "base64"),
+        Buffer.from(timeStamp, "utf8"),
     ]);
-    const signature = Buffer.from(hmac(sha256, hkdf)
+    const signature = Buffer.from(hashJs
+        .hmac(hashJs.sha256, hkdf)
         .update(concatBuffer)
-        .digest()).toString('base64');
+        .digest()).toString("base64");
     return {
         signature,
         timeStamp,
     };
 }
 export function decodeJwt(jwt) {
-    const [header, payload, signature] = jwt.split('.');
+    const [header, payload, signature] = jwt.split(".");
     return {
-        header: JSON.parse(Buffer.from(header, 'base64').toString('utf-8')),
-        payload: JSON.parse(Buffer.from(payload, 'base64').toString('utf-8')),
+        header: JSON.parse(Buffer.from(header, "base64").toString("utf-8")),
+        payload: JSON.parse(Buffer.from(payload, "base64").toString("utf-8")),
         signature: signature,
     };
 }
+export async function randomBytes(num) {
+    if (globalThis.window) {
+        const bytes = new Uint8Array(num);
+        window.crypto.getRandomValues(bytes);
+        return Buffer.from(bytes);
+    }
+    else {
+        const { randomBytes } = await import("node:crypto");
+        return randomBytes(num);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vardario/cognito-client",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "",
   "main": "lib/index.js",
   "type": "module",
@@ -11,28 +11,27 @@
   "license": "MIT",
   "dependencies": {
     "@vardario/cookies": "^0.1.4",
+    "buffer": "^6.0.3",
     "date-fns": "^2.29.3",
     "date-fns-tz": "^1.3.7",
-    "jsbn": "^1.1.0",
-    "randombytes": "^2.1.0",
-    "hash.js": "^1.1.7"
+    "hash.js": "^1.1.7",
+    "jsbn": "^1.1.0"
   },
   "devDependencies": {
     "@aws-sdk/client-cognito-identity-provider": "^3.209.0",
     "@types/jsbn": "^1.2.30",
     "@types/jsdom": "^20.0.1",
-    "@types/randombytes": "^2.0.0",
     "isomorphic-fetch": "^3.0.0",
     "jsdom": "^20.0.2",
     "testcontainers": "^9.0.0",
-    "ts-jest": "^29.0.3",
+    "typescript": "^5.1.3",
     "vitest": "^0.31.0"
   },
   "repository": {
     "type": "git",
     "url": "git@github.com:vardario/cognito-client.git"
   },
-  "packageManager": "pnpm@8.3.1",
+  "packageManager": "pnpm@8.6.0",
   "scripts": {
     "test": "vitest run",
     "build": "tsc --build",