Initial commit

node_modules/@azure/msal-node/src/cache/serializer/Deserializer.ts

@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+    AccountCache,
+    IdTokenCache,
+    AccessTokenCache,
+    RefreshTokenCache,
+    AppMetadataCache,
+    AccountEntity,
+    IdTokenEntity,
+    AccessTokenEntity,
+    RefreshTokenEntity,
+    CacheManager,
+    CredentialType,
+    AuthenticationScheme,
+} from "@azure/msal-common/node";
+import {
+    JsonCache,
+    InMemoryCache,
+    SerializedAccountEntity,
+    SerializedIdTokenEntity,
+    SerializedAccessTokenEntity,
+    SerializedRefreshTokenEntity,
+    SerializedAppMetadataEntity,
+} from "./SerializerTypes.js";
+
+/**
+ * This class deserializes cache entities read from the file into in-memory object types defined internally
+ * @internal
+ */
+export class Deserializer {
+    /**
+     * Parse the JSON blob in memory and deserialize the content
+     * @param cachedJson - JSON blob cache
+     */
+    static deserializeJSONBlob(jsonFile: string): JsonCache {
+        const deserializedCache = !jsonFile ? {} : JSON.parse(jsonFile);
+        return deserializedCache;
+    }
+
+    /**
+     * Deserializes accounts to AccountEntity objects
+     * @param accounts - accounts of type SerializedAccountEntity
+     */
+    static deserializeAccounts(
+        accounts: Record<string, SerializedAccountEntity>
+    ): AccountCache {
+        const accountObjects: AccountCache = {};
+        if (accounts) {
+            Object.keys(accounts).map(function (key) {
+                const serializedAcc = accounts[key];
+                const mappedAcc = {
+                    homeAccountId: serializedAcc.home_account_id,
+                    environment: serializedAcc.environment,
+                    realm: serializedAcc.realm,
+                    localAccountId: serializedAcc.local_account_id,
+                    username: serializedAcc.username,
+                    authorityType: serializedAcc.authority_type,
+                    name: serializedAcc.name,
+                    clientInfo: serializedAcc.client_info,
+                    lastModificationTime: serializedAcc.last_modification_time,
+                    lastModificationApp: serializedAcc.last_modification_app,
+                    tenantProfiles: serializedAcc.tenantProfiles?.map(
+                        (serializedTenantProfile) => {
+                            return JSON.parse(serializedTenantProfile);
+                        }
+                    ),
+                };
+                const account: AccountEntity = new AccountEntity();
+                CacheManager.toObject(account, mappedAcc);
+                accountObjects[key] = account;
+            });
+        }
+
+        return accountObjects;
+    }
+
+    /**
+     * Deserializes id tokens to IdTokenEntity objects
+     * @param idTokens - credentials of type SerializedIdTokenEntity
+     */
+    static deserializeIdTokens(
+        idTokens: Record<string, SerializedIdTokenEntity>
+    ): IdTokenCache {
+        const idObjects: IdTokenCache = {};
+        if (idTokens) {
+            Object.keys(idTokens).map(function (key) {
+                const serializedIdT = idTokens[key];
+                const idToken: IdTokenEntity = {
+                    homeAccountId: serializedIdT.home_account_id,
+                    environment: serializedIdT.environment,
+                    credentialType:
+                        serializedIdT.credential_type as CredentialType,
+                    clientId: serializedIdT.client_id,
+                    secret: serializedIdT.secret,
+                    realm: serializedIdT.realm,
+                };
+                idObjects[key] = idToken;
+            });
+        }
+        return idObjects;
+    }
+
+    /**
+     * Deserializes access tokens to AccessTokenEntity objects
+     * @param accessTokens - access tokens of type SerializedAccessTokenEntity
+     */
+    static deserializeAccessTokens(
+        accessTokens: Record<string, SerializedAccessTokenEntity>
+    ): AccessTokenCache {
+        const atObjects: AccessTokenCache = {};
+        if (accessTokens) {
+            Object.keys(accessTokens).map(function (key) {
+                const serializedAT = accessTokens[key];
+                const accessToken: AccessTokenEntity = {
+                    homeAccountId: serializedAT.home_account_id,
+                    environment: serializedAT.environment,
+                    credentialType:
+                        serializedAT.credential_type as CredentialType,
+                    clientId: serializedAT.client_id,
+                    secret: serializedAT.secret,
+                    realm: serializedAT.realm,
+                    target: serializedAT.target,
+                    cachedAt: serializedAT.cached_at,
+                    expiresOn: serializedAT.expires_on,
+                    extendedExpiresOn: serializedAT.extended_expires_on,
+                    refreshOn: serializedAT.refresh_on,
+                    keyId: serializedAT.key_id,
+                    tokenType: serializedAT.token_type as AuthenticationScheme,
+                    requestedClaims: serializedAT.requestedClaims,
+                    requestedClaimsHash: serializedAT.requestedClaimsHash,
+                    userAssertionHash: serializedAT.userAssertionHash,
+                };
+                atObjects[key] = accessToken;
+            });
+        }
+
+        return atObjects;
+    }
+
+    /**
+     * Deserializes refresh tokens to RefreshTokenEntity objects
+     * @param refreshTokens - refresh tokens of type SerializedRefreshTokenEntity
+     */
+    static deserializeRefreshTokens(
+        refreshTokens: Record<string, SerializedRefreshTokenEntity>
+    ): RefreshTokenCache {
+        const rtObjects: RefreshTokenCache = {};
+        if (refreshTokens) {
+            Object.keys(refreshTokens).map(function (key) {
+                const serializedRT = refreshTokens[key];
+                const refreshToken: RefreshTokenEntity = {
+                    homeAccountId: serializedRT.home_account_id,
+                    environment: serializedRT.environment,
+                    credentialType:
+                        serializedRT.credential_type as CredentialType,
+                    clientId: serializedRT.client_id,
+                    secret: serializedRT.secret,
+                    familyId: serializedRT.family_id,
+                    target: serializedRT.target,
+                    realm: serializedRT.realm,
+                };
+                rtObjects[key] = refreshToken;
+            });
+        }
+
+        return rtObjects;
+    }
+
+    /**
+     * Deserializes appMetadata to AppMetaData objects
+     * @param appMetadata - app metadata of type SerializedAppMetadataEntity
+     */
+    static deserializeAppMetadata(
+        appMetadata: Record<string, SerializedAppMetadataEntity>
+    ): AppMetadataCache {
+        const appMetadataObjects: AppMetadataCache = {};
+        if (appMetadata) {
+            Object.keys(appMetadata).map(function (key) {
+                const serializedAmdt = appMetadata[key];
+                appMetadataObjects[key] = {
+                    clientId: serializedAmdt.client_id,
+                    environment: serializedAmdt.environment,
+                    familyId: serializedAmdt.family_id,
+                };
+            });
+        }
+
+        return appMetadataObjects;
+    }
+
+    /**
+     * Deserialize an inMemory Cache
+     * @param jsonCache - JSON blob cache
+     */
+    static deserializeAllCache(jsonCache: JsonCache): InMemoryCache {
+        return {
+            accounts: jsonCache.Account
+                ? this.deserializeAccounts(jsonCache.Account)
+                : {},
+            idTokens: jsonCache.IdToken
+                ? this.deserializeIdTokens(jsonCache.IdToken)
+                : {},
+            accessTokens: jsonCache.AccessToken
+                ? this.deserializeAccessTokens(jsonCache.AccessToken)
+                : {},
+            refreshTokens: jsonCache.RefreshToken
+                ? this.deserializeRefreshTokens(jsonCache.RefreshToken)
+                : {},
+            appMetadata: jsonCache.AppMetadata
+                ? this.deserializeAppMetadata(jsonCache.AppMetadata)
+                : {},
+        };
+    }
+}

node_modules/@azure/msal-node/src/cache/serializer/Serializer.ts

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+    AccountCache,
+    IdTokenCache,
+    AccessTokenCache,
+    RefreshTokenCache,
+    AppMetadataCache,
+} from "@azure/msal-common/node";
+import {
+    InMemoryCache,
+    JsonCache,
+    SerializedAccountEntity,
+    SerializedIdTokenEntity,
+    SerializedAccessTokenEntity,
+    SerializedRefreshTokenEntity,
+    SerializedAppMetadataEntity,
+} from "./SerializerTypes.js";
+
+/**
+ * This class serializes cache entities to be saved into in-memory object types defined internally
+ * @internal
+ */
+export class Serializer {
+    /**
+     * serialize the JSON blob
+     * @param data - JSON blob cache
+     */
+    static serializeJSONBlob(data: JsonCache): string {
+        return JSON.stringify(data);
+    }
+
+    /**
+     * Serialize Accounts
+     * @param accCache - cache of accounts
+     */
+    static serializeAccounts(
+        accCache: AccountCache
+    ): Record<string, SerializedAccountEntity> {
+        const accounts: Record<string, SerializedAccountEntity> = {};
+        Object.keys(accCache).map(function (key) {
+            const accountEntity = accCache[key];
+            accounts[key] = {
+                home_account_id: accountEntity.homeAccountId,
+                environment: accountEntity.environment,
+                realm: accountEntity.realm,
+                local_account_id: accountEntity.localAccountId,
+                username: accountEntity.username,
+                authority_type: accountEntity.authorityType,
+                name: accountEntity.name,
+                client_info: accountEntity.clientInfo,
+                last_modification_time: accountEntity.lastModificationTime,
+                last_modification_app: accountEntity.lastModificationApp,
+                tenantProfiles: accountEntity.tenantProfiles?.map(
+                    (tenantProfile) => {
+                        return JSON.stringify(tenantProfile);
+                    }
+                ),
+            };
+        });
+
+        return accounts;
+    }
+
+    /**
+     * Serialize IdTokens
+     * @param idTCache - cache of ID tokens
+     */
+    static serializeIdTokens(
+        idTCache: IdTokenCache
+    ): Record<string, SerializedIdTokenEntity> {
+        const idTokens: Record<string, SerializedIdTokenEntity> = {};
+        Object.keys(idTCache).map(function (key) {
+            const idTEntity = idTCache[key];
+            idTokens[key] = {
+                home_account_id: idTEntity.homeAccountId,
+                environment: idTEntity.environment,
+                credential_type: idTEntity.credentialType,
+                client_id: idTEntity.clientId,
+                secret: idTEntity.secret,
+                realm: idTEntity.realm,
+            };
+        });
+
+        return idTokens;
+    }
+
+    /**
+     * Serializes AccessTokens
+     * @param atCache - cache of access tokens
+     */
+    static serializeAccessTokens(
+        atCache: AccessTokenCache
+    ): Record<string, SerializedAccessTokenEntity> {
+        const accessTokens: Record<string, SerializedAccessTokenEntity> = {};
+        Object.keys(atCache).map(function (key) {
+            const atEntity = atCache[key];
+            accessTokens[key] = {
+                home_account_id: atEntity.homeAccountId,
+                environment: atEntity.environment,
+                credential_type: atEntity.credentialType,
+                client_id: atEntity.clientId,
+                secret: atEntity.secret,
+                realm: atEntity.realm,
+                target: atEntity.target,
+                cached_at: atEntity.cachedAt,
+                expires_on: atEntity.expiresOn,
+                extended_expires_on: atEntity.extendedExpiresOn,
+                refresh_on: atEntity.refreshOn,
+                key_id: atEntity.keyId,
+                token_type: atEntity.tokenType,
+                requestedClaims: atEntity.requestedClaims,
+                requestedClaimsHash: atEntity.requestedClaimsHash,
+                userAssertionHash: atEntity.userAssertionHash,
+            };
+        });
+
+        return accessTokens;
+    }
+
+    /**
+     * Serialize refreshTokens
+     * @param rtCache - cache of refresh tokens
+     */
+    static serializeRefreshTokens(
+        rtCache: RefreshTokenCache
+    ): Record<string, SerializedRefreshTokenEntity> {
+        const refreshTokens: Record<string, SerializedRefreshTokenEntity> = {};
+        Object.keys(rtCache).map(function (key) {
+            const rtEntity = rtCache[key];
+            refreshTokens[key] = {
+                home_account_id: rtEntity.homeAccountId,
+                environment: rtEntity.environment,
+                credential_type: rtEntity.credentialType,
+                client_id: rtEntity.clientId,
+                secret: rtEntity.secret,
+                family_id: rtEntity.familyId,
+                target: rtEntity.target,
+                realm: rtEntity.realm,
+            };
+        });
+
+        return refreshTokens;
+    }
+
+    /**
+     * Serialize amdtCache
+     * @param amdtCache - cache of app metadata
+     */
+    static serializeAppMetadata(
+        amdtCache: AppMetadataCache
+    ): Record<string, SerializedAppMetadataEntity> {
+        const appMetadata: Record<string, SerializedAppMetadataEntity> = {};
+        Object.keys(amdtCache).map(function (key) {
+            const amdtEntity = amdtCache[key];
+            appMetadata[key] = {
+                client_id: amdtEntity.clientId,
+                environment: amdtEntity.environment,
+                family_id: amdtEntity.familyId,
+            };
+        });
+
+        return appMetadata;
+    }
+
+    /**
+     * Serialize the cache
+     * @param inMemCache - itemised cache read from the JSON
+     */
+    static serializeAllCache(inMemCache: InMemoryCache): JsonCache {
+        return {
+            Account: this.serializeAccounts(inMemCache.accounts),
+            IdToken: this.serializeIdTokens(inMemCache.idTokens),
+            AccessToken: this.serializeAccessTokens(inMemCache.accessTokens),
+            RefreshToken: this.serializeRefreshTokens(inMemCache.refreshTokens),
+            AppMetadata: this.serializeAppMetadata(inMemCache.appMetadata),
+        };
+    }
+}

node_modules/@azure/msal-node/src/cache/serializer/SerializerTypes.ts

@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+    AccountCache,
+    IdTokenCache,
+    AccessTokenCache,
+    RefreshTokenCache,
+    AppMetadataCache,
+    ValidCacheType,
+} from "@azure/msal-common/node";
+
+/**
+ * Key value store for in-memory cache
+ * @public
+ */
+export type CacheKVStore = Record<string, ValidCacheType>;
+
+/**
+ * Cache format read from the cache blob provided to the configuration during app instantiation
+ * @public
+ */
+export type JsonCache = {
+    Account: Record<string, SerializedAccountEntity>;
+    IdToken: Record<string, SerializedIdTokenEntity>;
+    AccessToken: Record<string, SerializedAccessTokenEntity>;
+    RefreshToken: Record<string, SerializedRefreshTokenEntity>;
+    AppMetadata: Record<string, SerializedAppMetadataEntity>;
+};
+
+/**
+ * Intermittent type to handle in-memory data objects with defined types
+ * @public
+ */
+export type InMemoryCache = {
+    accounts: AccountCache;
+    idTokens: IdTokenCache;
+    accessTokens: AccessTokenCache;
+    refreshTokens: RefreshTokenCache;
+    appMetadata: AppMetadataCache;
+};
+
+/**
+ * Account type
+ * @public
+ */
+export type SerializedAccountEntity = {
+    home_account_id: string;
+    environment: string;
+    realm: string;
+    local_account_id: string;
+    username: string;
+    authority_type: string;
+    name?: string;
+    client_info?: string;
+    last_modification_time?: string;
+    last_modification_app?: string;
+    tenantProfiles?: string[];
+};
+
+/**
+ * Idtoken credential type
+ * @public
+ */
+export type SerializedIdTokenEntity = {
+    home_account_id: string;
+    environment: string;
+    credential_type: string;
+    client_id: string;
+    secret: string;
+    realm: string;
+};
+
+/**
+ * Access token credential type
+ * @public
+ */
+export type SerializedAccessTokenEntity = {
+    home_account_id: string;
+    environment: string;
+    credential_type: string;
+    client_id: string;
+    secret: string;
+    realm: string;
+    target: string;
+    cached_at: string;
+    expires_on: string;
+    extended_expires_on?: string;
+    refresh_on?: string;
+    key_id?: string;
+    token_type?: string;
+    requestedClaims?: string;
+    requestedClaimsHash?: string;
+    userAssertionHash?: string;
+};
+
+/**
+ * Refresh token credential type
+ * @public
+ */
+export type SerializedRefreshTokenEntity = {
+    home_account_id: string;
+    environment: string;
+    credential_type: string;
+    client_id: string;
+    secret: string;
+    family_id?: string;
+    target?: string;
+    realm?: string;
+};
+
+/**
+ * AppMetadata type
+ * @public
+ */
+export type SerializedAppMetadataEntity = {
+    client_id: string;
+    environment: string;
+    family_id?: string;
+};