@pnp/cli-microsoft365 7.0.0-beta.f2e9fd9 → 7.0.0

package/dist/m365/aad/commands/app/app-add.js

@@ -1,31 +1,20 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _AadAppAddCommand_instances, _AadAppAddCommand_initTelemetry, _AadAppAddCommand_initOptions, _AadAppAddCommand_initValidators, _AadAppAddCommand_initOptionSets;
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = require("fs");
-const uuid_1 = require("uuid");
-const Auth_1 = require("../../../../Auth");
-const request_1 = require("../../../../request");
-const accessToken_1 = require("../../../../utils/accessToken");
-const odata_1 = require("../../../../utils/odata");
-const GraphCommand_1 = require("../../../base/GraphCommand");
-const commands_1 = require("../../commands");
-class AadAppAddCommand extends GraphCommand_1.default {
+var _AadAppAddCommand_instances, _a, _AadAppAddCommand_initTelemetry, _AadAppAddCommand_initOptions, _AadAppAddCommand_initValidators, _AadAppAddCommand_initOptionSets;
+import fs from 'fs';
+import { v4 } from 'uuid';
+import auth from '../../../../Auth.js';
+import request from '../../../../request.js';
+import { accessToken } from '../../../../utils/accessToken.js';
+import { odata } from '../../../../utils/odata.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class AadAppAddCommand extends GraphCommand {
     get name() {
-        return commands_1.default.APP_ADD;
+        return commands.APP_ADD;
     }
     get description() {
         return 'Creates new Azure AD app registration';
@@ -40,226 +29,212 @@ class AadAppAddCommand extends GraphCommand_1.default {
         __classPrivateFieldGet(this, _AadAppAddCommand_instances, "m", _AadAppAddCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _AadAppAddCommand_instances, "m", _AadAppAddCommand_initOptionSets).call(this);
     }
-    commandAction(logger, args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const apis = yield this.resolveApis(args, logger);
-                let appInfo = yield this.createAppRegistration(args, apis, logger);
-                // based on the assumption that we're adding AAD app to the current
-                // directory. If we in the future extend the command with allowing
-                // users to create AAD app in a different directory, we'll need to
-                // adjust this
-                appInfo.tenantId = accessToken_1.accessToken.getTenantIdFromAccessToken(Auth_1.default.service.accessTokens[Auth_1.default.defaultResource].accessToken);
-                appInfo = yield this.updateAppFromManifest(args, appInfo);
-                appInfo = yield this.grantAdminConsent(appInfo, args.options.grantAdminConsent, logger);
-                appInfo = yield this.configureUri(args, appInfo, logger);
-                appInfo = yield this.configureSecret(args, appInfo, logger);
-                const _appInfo = yield this.saveAppInfo(args, appInfo, logger);
-                appInfo = {
-                    appId: _appInfo.appId,
-                    objectId: _appInfo.id,
-                    tenantId: _appInfo.tenantId
-                };
-                if (_appInfo.secrets) {
-                    appInfo.secrets = _appInfo.secrets;
-                }
-                logger.log(appInfo);
-            }
-            catch (err) {
-                this.handleRejectedODataJsonPromise(err);
+    async commandAction(logger, args) {
+        try {
+            const apis = await this.resolveApis(args, logger);
+            let appInfo = await this.createAppRegistration(args, apis, logger);
+            // based on the assumption that we're adding AAD app to the current
+            // directory. If we in the future extend the command with allowing
+            // users to create AAD app in a different directory, we'll need to
+            // adjust this
+            appInfo.tenantId = accessToken.getTenantIdFromAccessToken(auth.service.accessTokens[auth.defaultResource].accessToken);
+            appInfo = await this.updateAppFromManifest(args, appInfo);
+            appInfo = await this.grantAdminConsent(appInfo, args.options.grantAdminConsent, logger);
+            appInfo = await this.configureUri(args, appInfo, logger);
+            appInfo = await this.configureSecret(args, appInfo, logger);
+            const _appInfo = await this.saveAppInfo(args, appInfo, logger);
+            appInfo = {
+                appId: _appInfo.appId,
+                objectId: _appInfo.id,
+                tenantId: _appInfo.tenantId
+            };
+            if (_appInfo.secrets) {
+                appInfo.secrets = _appInfo.secrets;
             }
-        });
+            await logger.log(appInfo);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
     }
-    createAppRegistration(args, apis, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const applicationInfo = {
-                displayName: args.options.name,
-                signInAudience: args.options.multitenant ? 'AzureADMultipleOrgs' : 'AzureADMyOrg'
+    async createAppRegistration(args, apis, logger) {
+        const applicationInfo = {
+            displayName: args.options.name,
+            signInAudience: args.options.multitenant ? 'AzureADMultipleOrgs' : 'AzureADMyOrg'
+        };
+        if (!applicationInfo.displayName && this.manifest) {
+            applicationInfo.displayName = this.manifest.name;
+        }
+        this.appName = applicationInfo.displayName;
+        if (apis.length > 0) {
+            applicationInfo.requiredResourceAccess = apis;
+        }
+        if (args.options.redirectUris) {
+            applicationInfo[args.options.platform] = {
+                redirectUris: args.options.redirectUris.split(',').map(u => u.trim())
             };
-            if (!applicationInfo.displayName && this.manifest) {
-                applicationInfo.displayName = this.manifest.name;
-            }
-            this.appName = applicationInfo.displayName;
-            if (apis.length > 0) {
-                applicationInfo.requiredResourceAccess = apis;
-            }
-            if (args.options.redirectUris) {
-                applicationInfo[args.options.platform] = {
-                    redirectUris: args.options.redirectUris.split(',').map(u => u.trim())
-                };
-            }
-            if (args.options.implicitFlow) {
-                if (!applicationInfo.web) {
-                    applicationInfo.web = {};
-                }
-                applicationInfo.web.implicitGrantSettings = {
-                    enableAccessTokenIssuance: true,
-                    enableIdTokenIssuance: true
-                };
-            }
-            if (args.options.certificateFile || args.options.certificateBase64Encoded) {
-                const certificateBase64Encoded = this.getCertificateBase64Encoded(args, logger);
-                const newKeyCredential = {
-                    type: "AsymmetricX509Cert",
-                    usage: "Verify",
-                    displayName: args.options.certificateDisplayName,
-                    key: certificateBase64Encoded
-                };
-                applicationInfo.keyCredentials = [newKeyCredential];
-            }
-            if (this.verbose) {
-                logger.logToStderr(`Creating Azure AD app registration...`);
+        }
+        if (args.options.implicitFlow) {
+            if (!applicationInfo.web) {
+                applicationInfo.web = {};
             }
-            const createApplicationRequestOptions = {
-                url: `${this.resource}/v1.0/myorganization/applications`,
-                headers: {
-                    accept: 'application/json;odata.metadata=none'
-                },
-                responseType: 'json',
-                data: applicationInfo
+            applicationInfo.web.implicitGrantSettings = {
+                enableAccessTokenIssuance: true,
+                enableIdTokenIssuance: true
             };
-            return request_1.default.post(createApplicationRequestOptions);
-        });
+        }
+        if (args.options.certificateFile || args.options.certificateBase64Encoded) {
+            const certificateBase64Encoded = await this.getCertificateBase64Encoded(args, logger);
+            const newKeyCredential = {
+                type: "AsymmetricX509Cert",
+                usage: "Verify",
+                displayName: args.options.certificateDisplayName,
+                key: certificateBase64Encoded
+            };
+            applicationInfo.keyCredentials = [newKeyCredential];
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Creating Azure AD app registration...`);
+        }
+        const createApplicationRequestOptions = {
+            url: `${this.resource}/v1.0/myorganization/applications`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json',
+            data: applicationInfo
+        };
+        return request.post(createApplicationRequestOptions);
     }
-    grantAdminConsent(appInfo, adminConsent, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!adminConsent || this.appPermissions.length === 0) {
-                return appInfo;
-            }
-            const sp = yield this.createServicePrincipal(appInfo.appId);
-            if (this.debug) {
-                logger.logToStderr("Service principal created, returned object id: " + sp.id);
+    async grantAdminConsent(appInfo, adminConsent, logger) {
+        if (!adminConsent || this.appPermissions.length === 0) {
+            return appInfo;
+        }
+        const sp = await this.createServicePrincipal(appInfo.appId);
+        if (this.debug) {
+            await logger.logToStderr("Service principal created, returned object id: " + sp.id);
+        }
+        const tasks = [];
+        this.appPermissions.forEach(async (permission) => {
+            if (permission.scope.length > 0) {
+                tasks.push(this.grantOAuth2Permission(sp.id, permission.resourceId, permission.scope.join(' ')));
+                if (this.debug) {
+                    await logger.logToStderr(`Admin consent granted for following resource ${permission.resourceId}, with delegated permissions: ${permission.scope.join(',')}`);
+                }
             }
-            const tasks = [];
-            this.appPermissions.forEach(permission => {
-                if (permission.scope.length > 0) {
-                    tasks.push(this.grantOAuth2Permission(sp.id, permission.resourceId, permission.scope.join(' ')));
-                    if (this.debug) {
-                        logger.logToStderr(`Admin consent granted for following resource ${permission.resourceId}, with delegated permissions: ${permission.scope.join(',')}`);
-                    }
+            permission.resourceAccess.filter(access => access.type === "Role").forEach(async (access) => {
+                tasks.push(this.addRoleToServicePrincipal(sp.id, permission.resourceId, access.id));
+                if (this.debug) {
+                    await logger.logToStderr(`Admin consent granted for following resource ${permission.resourceId}, with application permission: ${access.id}`);
                 }
-                permission.resourceAccess.filter(access => access.type === "Role").forEach((access) => {
-                    tasks.push(this.addRoleToServicePrincipal(sp.id, permission.resourceId, access.id));
-                    if (this.debug) {
-                        logger.logToStderr(`Admin consent granted for following resource ${permission.resourceId}, with application permission: ${access.id}`);
-                    }
-                });
             });
-            yield Promise.all(tasks);
-            return appInfo;
         });
+        await Promise.all(tasks);
+        return appInfo;
     }
-    addRoleToServicePrincipal(objectId, resourceId, appRoleId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = {
-                url: `${this.resource}/v1.0/myorganization/servicePrincipals/${objectId}/appRoleAssignments`,
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                responseType: 'json',
-                data: {
-                    appRoleId: appRoleId,
-                    principalId: objectId,
-                    resourceId: resourceId
-                }
-            };
-            return request_1.default.post(requestOptions);
-        });
+    async addRoleToServicePrincipal(objectId, resourceId, appRoleId) {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/myorganization/servicePrincipals/${objectId}/appRoleAssignments`,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            responseType: 'json',
+            data: {
+                appRoleId: appRoleId,
+                principalId: objectId,
+                resourceId: resourceId
+            }
+        };
+        return request.post(requestOptions);
     }
-    grantOAuth2Permission(appId, resourceId, scopeName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const grantAdminConsentApplicationRequestOptions = {
-                url: `${this.resource}/v1.0/myorganization/oauth2PermissionGrants`,
-                headers: {
-                    accept: 'application/json;odata.metadata=none'
-                },
-                responseType: 'json',
-                data: {
-                    clientId: appId,
-                    consentType: "AllPrincipals",
-                    principalId: null,
-                    resourceId: resourceId,
-                    scope: scopeName
-                }
-            };
-            return request_1.default.post(grantAdminConsentApplicationRequestOptions);
-        });
+    async grantOAuth2Permission(appId, resourceId, scopeName) {
+        const grantAdminConsentApplicationRequestOptions = {
+            url: `${this.resource}/v1.0/myorganization/oauth2PermissionGrants`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json',
+            data: {
+                clientId: appId,
+                consentType: "AllPrincipals",
+                principalId: null,
+                resourceId: resourceId,
+                scope: scopeName
+            }
+        };
+        return request.post(grantAdminConsentApplicationRequestOptions);
     }
-    createServicePrincipal(appId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = {
-                url: `${this.resource}/v1.0/myorganization/servicePrincipals`,
-                headers: {
-                    'content-type': 'application/json'
-                },
-                data: {
-                    appId: appId
-                },
-                responseType: 'json'
-            };
-            return request_1.default.post(requestOptions);
-        });
+    async createServicePrincipal(appId) {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/myorganization/servicePrincipals`,
+            headers: {
+                'content-type': 'application/json'
+            },
+            data: {
+                appId: appId
+            },
+            responseType: 'json'
+        };
+        return request.post(requestOptions);
     }
-    updateAppFromManifest(args, appInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args.options.manifest) {
-                return appInfo;
-            }
-            const v2Manifest = JSON.parse(args.options.manifest);
-            // remove properties that might be coming from the original app that was
-            // used to create the manifest and which can't be updated
-            delete v2Manifest.id;
-            delete v2Manifest.appId;
-            delete v2Manifest.publisherDomain;
-            // extract secrets from the manifest. Store them in a separate variable
-            const secrets = this.getSecretsFromManifest(v2Manifest);
-            // Azure Portal returns v2 manifest whereas the Graph API expects a v1.6
-            if (args.options.apisApplication || args.options.apisDelegated) {
-                // take submitted delegated / application permissions as options
-                // otherwise, they will be skipped in the app update
-                v2Manifest.requiredResourceAccess = appInfo.requiredResourceAccess;
-            }
-            if (args.options.redirectUris) {
-                // take submitted redirectUris/platform as options
-                // otherwise, they will be removed from the app
-                v2Manifest.replyUrlsWithType = args.options.redirectUris.split(',').map(u => {
-                    return {
-                        url: u.trim(),
-                        type: this.translatePlatformToType(args.options.platform)
-                    };
-                });
-            }
-            if (args.options.multitenant) {
-                // override manifest setting when using multitenant flag
-                v2Manifest.signInAudience = 'AzureADMultipleOrgs';
-            }
-            if (args.options.implicitFlow) {
-                // remove manifest settings when using implicitFlow flag
-                delete v2Manifest.oauth2AllowIdTokenImplicitFlow;
-                delete v2Manifest.oauth2AllowImplicitFlow;
-            }
-            if (args.options.scopeName) {
-                // override manifest setting when using options.
-                delete v2Manifest.oauth2Permissions;
-            }
-            if (args.options.certificateFile || args.options.certificateBase64Encoded) {
-                // override manifest setting when using options.
-                delete v2Manifest.keyCredentials;
-            }
-            const graphManifest = this.transformManifest(v2Manifest);
-            const updateAppRequestOptions = {
-                url: `${this.resource}/v1.0/myorganization/applications/${appInfo.id}`,
-                headers: {
-                    'content-type': 'application/json'
-                },
-                responseType: 'json',
-                data: graphManifest
-            };
-            yield request_1.default.patch(updateAppRequestOptions);
-            yield this.updatePreAuthorizedAppsFromManifest(v2Manifest, appInfo);
-            yield this.createSecrets(secrets, appInfo);
+    async updateAppFromManifest(args, appInfo) {
+        if (!args.options.manifest) {
             return appInfo;
-        });
+        }
+        const v2Manifest = JSON.parse(args.options.manifest);
+        // remove properties that might be coming from the original app that was
+        // used to create the manifest and which can't be updated
+        delete v2Manifest.id;
+        delete v2Manifest.appId;
+        delete v2Manifest.publisherDomain;
+        // extract secrets from the manifest. Store them in a separate variable
+        const secrets = this.getSecretsFromManifest(v2Manifest);
+        // Azure Portal returns v2 manifest whereas the Graph API expects a v1.6
+        if (args.options.apisApplication || args.options.apisDelegated) {
+            // take submitted delegated / application permissions as options
+            // otherwise, they will be skipped in the app update
+            v2Manifest.requiredResourceAccess = appInfo.requiredResourceAccess;
+        }
+        if (args.options.redirectUris) {
+            // take submitted redirectUris/platform as options
+            // otherwise, they will be removed from the app
+            v2Manifest.replyUrlsWithType = args.options.redirectUris.split(',').map(u => {
+                return {
+                    url: u.trim(),
+                    type: this.translatePlatformToType(args.options.platform)
+                };
+            });
+        }
+        if (args.options.multitenant) {
+            // override manifest setting when using multitenant flag
+            v2Manifest.signInAudience = 'AzureADMultipleOrgs';
+        }
+        if (args.options.implicitFlow) {
+            // remove manifest settings when using implicitFlow flag
+            delete v2Manifest.oauth2AllowIdTokenImplicitFlow;
+            delete v2Manifest.oauth2AllowImplicitFlow;
+        }
+        if (args.options.scopeName) {
+            // override manifest setting when using options.
+            delete v2Manifest.oauth2Permissions;
+        }
+        if (args.options.certificateFile || args.options.certificateBase64Encoded) {
+            // override manifest setting when using options.
+            delete v2Manifest.keyCredentials;
+        }
+        const graphManifest = this.transformManifest(v2Manifest);
+        const updateAppRequestOptions = {
+            url: `${this.resource}/v1.0/myorganization/applications/${appInfo.id}`,
+            headers: {
+                'content-type': 'application/json'
+            },
+            responseType: 'json',
+            data: graphManifest
+        };
+        await request.patch(updateAppRequestOptions);
+        await this.updatePreAuthorizedAppsFromManifest(v2Manifest, appInfo);
+        await this.createSecrets(secrets, appInfo);
+        return appInfo;
     }
     getSecretsFromManifest(manifest) {
         if (!manifest.passwordCredentials || manifest.passwordCredentials.length === 0) {
@@ -280,51 +255,46 @@ class AadAppAddCommand extends GraphCommand_1.default {
         delete manifest.passwordCredentials;
         return secrets;
     }
-    updatePreAuthorizedAppsFromManifest(manifest, appInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!manifest ||
-                !manifest.preAuthorizedApplications ||
-                manifest.preAuthorizedApplications.length === 0) {
-                return appInfo;
-            }
-            const graphManifest = {
-                api: {
-                    preAuthorizedApplications: manifest.preAuthorizedApplications
-                }
-            };
-            graphManifest.api.preAuthorizedApplications.forEach((p) => {
-                p.delegatedPermissionIds = p.permissionIds;
-                delete p.permissionIds;
-            });
-            const updateAppRequestOptions = {
-                url: `${this.resource}/v1.0/myorganization/applications/${appInfo.id}`,
-                headers: {
-                    'content-type': 'application/json'
-                },
-                responseType: 'json',
-                data: graphManifest
-            };
-            yield request_1.default.patch(updateAppRequestOptions);
+    async updatePreAuthorizedAppsFromManifest(manifest, appInfo) {
+        if (!manifest ||
+            !manifest.preAuthorizedApplications ||
+            manifest.preAuthorizedApplications.length === 0) {
             return appInfo;
+        }
+        const graphManifest = {
+            api: {
+                preAuthorizedApplications: manifest.preAuthorizedApplications
+            }
+        };
+        graphManifest.api.preAuthorizedApplications.forEach((p) => {
+            p.delegatedPermissionIds = p.permissionIds;
+            delete p.permissionIds;
         });
+        const updateAppRequestOptions = {
+            url: `${this.resource}/v1.0/myorganization/applications/${appInfo.id}`,
+            headers: {
+                'content-type': 'application/json'
+            },
+            responseType: 'json',
+            data: graphManifest
+        };
+        await request.patch(updateAppRequestOptions);
+        return appInfo;
     }
-    createSecrets(secrets, appInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (secrets.length === 0) {
-                return appInfo;
-            }
-            const secretsOutput = yield Promise
-                .all(secrets.map(secret => this.createSecret({
-                appObjectId: appInfo.id,
-                displayName: secret.name,
-                expirationDate: secret.expirationDate
-            })));
-            appInfo.secrets = secretsOutput;
+    async createSecrets(secrets, appInfo) {
+        if (secrets.length === 0) {
             return appInfo;
-        });
+        }
+        const secretsOutput = await Promise
+            .all(secrets.map(secret => this.createSecret({
+            appObjectId: appInfo.id,
+            displayName: secret.name,
+            expirationDate: secret.expirationDate
+        })));
+        appInfo.secrets = secretsOutput;
+        return appInfo;
     }
     transformManifest(v2Manifest) {
-        var _a, _b, _c, _d;
         const graphManifest = JSON.parse(JSON.stringify(v2Manifest));
         // add missing properties
         if (!graphManifest.api) {
@@ -359,10 +329,10 @@ class AadAppAddCommand extends GraphCommand_1.default {
         delete graphManifest.acceptMappedClaims;
         graphManifest.isFallbackPublicClient = v2Manifest.allowPublicClient;
         delete graphManifest.allowPublicClient;
-        graphManifest.info.termsOfServiceUrl = (_a = v2Manifest.informationalUrls) === null || _a === void 0 ? void 0 : _a.termsOfService;
-        graphManifest.info.supportUrl = (_b = v2Manifest.informationalUrls) === null || _b === void 0 ? void 0 : _b.support;
-        graphManifest.info.privacyStatementUrl = (_c = v2Manifest.informationalUrls) === null || _c === void 0 ? void 0 : _c.privacy;
-        graphManifest.info.marketingUrl = (_d = v2Manifest.informationalUrls) === null || _d === void 0 ? void 0 : _d.marketing;
+        graphManifest.info.termsOfServiceUrl = v2Manifest.informationalUrls?.termsOfService;
+        graphManifest.info.supportUrl = v2Manifest.informationalUrls?.support;
+        graphManifest.info.privacyStatementUrl = v2Manifest.informationalUrls?.privacy;
+        graphManifest.info.marketingUrl = v2Manifest.informationalUrls?.marketing;
         delete graphManifest.informationalUrls;
         graphManifest.api.knownClientApplications = v2Manifest.knownClientApplications;
         delete graphManifest.knownClientApplications;
@@ -411,119 +381,113 @@ class AadAppAddCommand extends GraphCommand_1.default {
         }
         return graphManifest;
     }
-    configureUri(args, appInfo, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args.options.uri) {
-                return appInfo;
-            }
-            if (this.verbose) {
-                logger.logToStderr(`Configuring Azure AD application ID URI...`);
-            }
-            const applicationInfo = {};
-            if (args.options.uri) {
-                const appUri = args.options.uri.replace(/_appId_/g, appInfo.appId);
-                applicationInfo.identifierUris = [appUri];
-            }
-            if (args.options.scopeName) {
-                applicationInfo.api = {
-                    oauth2PermissionScopes: [{
-                            adminConsentDescription: args.options.scopeAdminConsentDescription,
-                            adminConsentDisplayName: args.options.scopeAdminConsentDisplayName,
-                            id: (0, uuid_1.v4)(),
-                            type: args.options.scopeConsentBy === 'adminsAndUsers' ? 'User' : 'Admin',
-                            value: args.options.scopeName
-                        }]
-                };
-            }
-            const requestOptions = {
-                url: `${this.resource}/v1.0/myorganization/applications/${appInfo.id}`,
-                headers: {
-                    'content-type': 'application/json;odata.metadata=none'
-                },
-                responseType: 'json',
-                data: applicationInfo
-            };
-            yield request_1.default.patch(requestOptions);
+    async configureUri(args, appInfo, logger) {
+        if (!args.options.uri) {
             return appInfo;
-        });
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Configuring Azure AD application ID URI...`);
+        }
+        const applicationInfo = {};
+        if (args.options.uri) {
+            const appUri = args.options.uri.replace(/_appId_/g, appInfo.appId);
+            applicationInfo.identifierUris = [appUri];
+        }
+        if (args.options.scopeName) {
+            applicationInfo.api = {
+                oauth2PermissionScopes: [{
+                        adminConsentDescription: args.options.scopeAdminConsentDescription,
+                        adminConsentDisplayName: args.options.scopeAdminConsentDisplayName,
+                        id: v4(),
+                        type: args.options.scopeConsentBy === 'adminsAndUsers' ? 'User' : 'Admin',
+                        value: args.options.scopeName
+                    }]
+            };
+        }
+        const requestOptions = {
+            url: `${this.resource}/v1.0/myorganization/applications/${appInfo.id}`,
+            headers: {
+                'content-type': 'application/json;odata.metadata=none'
+            },
+            responseType: 'json',
+            data: applicationInfo
+        };
+        await request.patch(requestOptions);
+        return appInfo;
     }
-    resolveApis(args, logger) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args.options.apisDelegated && !args.options.apisApplication
-                && (typeof ((_a = this.manifest) === null || _a === void 0 ? void 0 : _a.requiredResourceAccess) === 'undefined' || this.manifest.requiredResourceAccess.length === 0)) {
-                return [];
-            }
-            if (this.verbose) {
-                logger.logToStderr('Resolving requested APIs...');
-            }
-            const servicePrincipals = yield odata_1.odata.getAllItems(`${this.resource}/v1.0/myorganization/servicePrincipals?$select=appId,appRoles,id,oauth2PermissionScopes,servicePrincipalNames`);
-            let resolvedApis = [];
-            try {
-                if (args.options.apisDelegated || args.options.apisApplication) {
-                    resolvedApis = this.getRequiredResourceAccessForApis(servicePrincipals, args.options.apisDelegated, 'Scope', logger);
-                    if (this.verbose) {
-                        logger.logToStderr(`Resolved delegated permissions: ${JSON.stringify(resolvedApis, null, 2)}`);
-                    }
-                    const resolvedApplicationApis = this.getRequiredResourceAccessForApis(servicePrincipals, args.options.apisApplication, 'Role', logger);
-                    if (this.verbose) {
-                        logger.logToStderr(`Resolved application permissions: ${JSON.stringify(resolvedApplicationApis, null, 2)}`);
-                    }
-                    // merge resolved application APIs onto resolved delegated APIs
-                    resolvedApplicationApis.forEach(resolvedRequiredResource => {
-                        const requiredResource = resolvedApis.find(api => api.resourceAppId === resolvedRequiredResource.resourceAppId);
-                        if (requiredResource) {
-                            requiredResource.resourceAccess.push(...resolvedRequiredResource.resourceAccess);
-                        }
-                        else {
-                            resolvedApis.push(resolvedRequiredResource);
-                        }
-                    });
-                }
-                else {
-                    const manifestApis = this.manifest.requiredResourceAccess;
-                    manifestApis.forEach(manifestApi => {
-                        resolvedApis.push(manifestApi);
-                        const app = servicePrincipals.find(servicePrincipals => servicePrincipals.appId === manifestApi.resourceAppId);
-                        if (app) {
-                            manifestApi.resourceAccess.forEach((res => {
-                                var _a;
-                                const resourceAccessPermission = {
-                                    id: res.id,
-                                    type: res.type
-                                };
-                                const oAuthValue = (_a = app.oauth2PermissionScopes.find(scp => scp.id === res.id)) === null || _a === void 0 ? void 0 : _a.value;
-                                this.updateAppPermissions(app.id, resourceAccessPermission, oAuthValue);
-                            }));
-                        }
-                    });
+    async resolveApis(args, logger) {
+        if (!args.options.apisDelegated && !args.options.apisApplication
+            && (typeof this.manifest?.requiredResourceAccess === 'undefined' || this.manifest.requiredResourceAccess.length === 0)) {
+            return [];
+        }
+        if (this.verbose) {
+            await logger.logToStderr('Resolving requested APIs...');
+        }
+        const servicePrincipals = await odata.getAllItems(`${this.resource}/v1.0/myorganization/servicePrincipals?$select=appId,appRoles,id,oauth2PermissionScopes,servicePrincipalNames`);
+        let resolvedApis = [];
+        try {
+            if (args.options.apisDelegated || args.options.apisApplication) {
+                resolvedApis = await this.getRequiredResourceAccessForApis(servicePrincipals, args.options.apisDelegated, 'Scope', logger);
+                if (this.verbose) {
+                    await logger.logToStderr(`Resolved delegated permissions: ${JSON.stringify(resolvedApis, null, 2)}`);
                 }
+                const resolvedApplicationApis = await this.getRequiredResourceAccessForApis(servicePrincipals, args.options.apisApplication, 'Role', logger);
                 if (this.verbose) {
-                    logger.logToStderr(`Merged delegated and application permissions: ${JSON.stringify(resolvedApis, null, 2)}`);
-                    logger.logToStderr(`App role assignments: ${JSON.stringify(this.appPermissions.flatMap(permission => permission.resourceAccess.filter(access => access.type === "Role")), null, 2)}`);
-                    logger.logToStderr(`OAuth2 permissions: ${JSON.stringify(this.appPermissions.flatMap(permission => permission.scope), null, 2)}`);
+                    await logger.logToStderr(`Resolved application permissions: ${JSON.stringify(resolvedApplicationApis, null, 2)}`);
                 }
-                return resolvedApis;
+                // merge resolved application APIs onto resolved delegated APIs
+                resolvedApplicationApis.forEach(resolvedRequiredResource => {
+                    const requiredResource = resolvedApis.find(api => api.resourceAppId === resolvedRequiredResource.resourceAppId);
+                    if (requiredResource) {
+                        requiredResource.resourceAccess.push(...resolvedRequiredResource.resourceAccess);
+                    }
+                    else {
+                        resolvedApis.push(resolvedRequiredResource);
+                    }
+                });
             }
-            catch (e) {
-                throw e;
+            else {
+                const manifestApis = this.manifest.requiredResourceAccess;
+                manifestApis.forEach(manifestApi => {
+                    resolvedApis.push(manifestApi);
+                    const app = servicePrincipals.find(servicePrincipals => servicePrincipals.appId === manifestApi.resourceAppId);
+                    if (app) {
+                        manifestApi.resourceAccess.forEach((res => {
+                            const resourceAccessPermission = {
+                                id: res.id,
+                                type: res.type
+                            };
+                            const oAuthValue = app.oauth2PermissionScopes.find(scp => scp.id === res.id)?.value;
+                            this.updateAppPermissions(app.id, resourceAccessPermission, oAuthValue);
+                        }));
+                    }
+                });
             }
-        });
+            if (this.verbose) {
+                await logger.logToStderr(`Merged delegated and application permissions: ${JSON.stringify(resolvedApis, null, 2)}`);
+                await logger.logToStderr(`App role assignments: ${JSON.stringify(this.appPermissions.flatMap(permission => permission.resourceAccess.filter(access => access.type === "Role")), null, 2)}`);
+                await logger.logToStderr(`OAuth2 permissions: ${JSON.stringify(this.appPermissions.flatMap(permission => permission.scope), null, 2)}`);
+            }
+            return resolvedApis;
+        }
+        catch (e) {
+            throw e;
+        }
     }
-    getRequiredResourceAccessForApis(servicePrincipals, apis, scopeType, logger) {
+    async getRequiredResourceAccessForApis(servicePrincipals, apis, scopeType, logger) {
         if (!apis) {
             return [];
         }
         const resolvedApis = [];
         const requestedApis = apis.split(',').map(a => a.trim());
-        requestedApis.forEach(api => {
+        for (const api of requestedApis) {
             const pos = api.lastIndexOf('/');
             const permissionName = api.substr(pos + 1);
             const servicePrincipalName = api.substr(0, pos);
             if (this.debug) {
-                logger.logToStderr(`Resolving ${api}...`);
-                logger.logToStderr(`Permission name: ${permissionName}`);
-                logger.logToStderr(`Service principal name: ${servicePrincipalName}`);
+                await logger.logToStderr(`Resolving ${api}...`);
+                await logger.logToStderr(`Permission name: ${permissionName}`);
+                await logger.logToStderr(`Service principal name: ${servicePrincipalName}`);
             }
             const servicePrincipal = servicePrincipals.find(sp => (sp.servicePrincipalNames.indexOf(servicePrincipalName) > -1 ||
                 sp.servicePrincipalNames.indexOf(`${servicePrincipalName}/`) > -1));
@@ -549,7 +513,7 @@ class AadAppAddCommand extends GraphCommand_1.default {
             };
             resolvedApi.resourceAccess.push(resourceAccessPermission);
             this.updateAppPermissions(servicePrincipal.id, resourceAccessPermission, permission.value);
-        });
+        }
         return resolvedApis;
     }
     updateAppPermissions(spId, resourceAccessPermission, oAuth2PermissionValue) {
@@ -571,56 +535,52 @@ class AadAppAddCommand extends GraphCommand_1.default {
             existingPermission.resourceAccess.push(resourceAccessPermission);
         }
     }
-    configureSecret(args, appInfo, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args.options.withSecret || (appInfo.secrets && appInfo.secrets.length > 0)) {
-                return appInfo;
-            }
-            if (this.verbose) {
-                logger.logToStderr(`Configure Azure AD app secret...`);
-            }
-            const secret = yield this.createSecret({ appObjectId: appInfo.id });
-            if (!appInfo.secrets) {
-                appInfo.secrets = [];
-            }
-            appInfo.secrets.push(secret);
+    async configureSecret(args, appInfo, logger) {
+        if (!args.options.withSecret || (appInfo.secrets && appInfo.secrets.length > 0)) {
             return appInfo;
-        });
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Configure Azure AD app secret...`);
+        }
+        const secret = await this.createSecret({ appObjectId: appInfo.id });
+        if (!appInfo.secrets) {
+            appInfo.secrets = [];
+        }
+        appInfo.secrets.push(secret);
+        return appInfo;
     }
-    createSecret({ appObjectId, displayName = undefined, expirationDate = undefined }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let secretExpirationDate = expirationDate;
-            if (!secretExpirationDate) {
-                secretExpirationDate = new Date();
-                secretExpirationDate.setFullYear(secretExpirationDate.getFullYear() + 1);
-            }
-            const secretName = displayName !== null && displayName !== void 0 ? displayName : 'Default';
-            const requestOptions = {
-                url: `${this.resource}/v1.0/myorganization/applications/${appObjectId}/addPassword`,
-                headers: {
-                    'content-type': 'application/json'
-                },
-                responseType: 'json',
-                data: {
-                    passwordCredential: {
-                        displayName: secretName,
-                        endDateTime: secretExpirationDate.toISOString()
-                    }
+    async createSecret({ appObjectId, displayName = undefined, expirationDate = undefined }) {
+        let secretExpirationDate = expirationDate;
+        if (!secretExpirationDate) {
+            secretExpirationDate = new Date();
+            secretExpirationDate.setFullYear(secretExpirationDate.getFullYear() + 1);
+        }
+        const secretName = displayName ?? 'Default';
+        const requestOptions = {
+            url: `${this.resource}/v1.0/myorganization/applications/${appObjectId}/addPassword`,
+            headers: {
+                'content-type': 'application/json'
+            },
+            responseType: 'json',
+            data: {
+                passwordCredential: {
+                    displayName: secretName,
+                    endDateTime: secretExpirationDate.toISOString()
                 }
-            };
-            const response = yield request_1.default.post(requestOptions);
-            return {
-                displayName: secretName,
-                value: response.secretText
-            };
-        });
+            }
+        };
+        const response = await request.post(requestOptions);
+        return {
+            displayName: secretName,
+            value: response.secretText
+        };
     }
-    getCertificateBase64Encoded(args, logger) {
+    async getCertificateBase64Encoded(args, logger) {
         if (args.options.certificateBase64Encoded) {
             return args.options.certificateBase64Encoded;
         }
         if (this.debug) {
-            logger.logToStderr(`Reading existing ${args.options.certificateFile}...`);
+            await logger.logToStderr(`Reading existing ${args.options.certificateFile}...`);
         }
         try {
             return fs.readFileSync(args.options.certificateFile, { encoding: 'base64' });
@@ -629,46 +589,44 @@ class AadAppAddCommand extends GraphCommand_1.default {
             throw new Error(`Error reading certificate file: ${e}. Please add the certificate using base64 option '--certificateBase64Encoded'.`);
         }
     }
-    saveAppInfo(args, appInfo, logger) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!args.options.save) {
-                return appInfo;
-            }
-            const filePath = '.m365rc.json';
-            if (this.verbose) {
-                logger.logToStderr(`Saving Azure AD app registration information to the ${filePath} file...`);
-            }
-            let m365rc = {};
-            if (fs.existsSync(filePath)) {
-                if (this.debug) {
-                    logger.logToStderr(`Reading existing ${filePath}...`);
-                }
-                try {
-                    const fileContents = fs.readFileSync(filePath, 'utf8');
-                    if (fileContents) {
-                        m365rc = JSON.parse(fileContents);
-                    }
-                }
-                catch (e) {
-                    logger.logToStderr(`Error reading ${filePath}: ${e}. Please add app info to ${filePath} manually.`);
-                    return appInfo;
-                }
-            }
-            if (!m365rc.apps) {
-                m365rc.apps = [];
+    async saveAppInfo(args, appInfo, logger) {
+        if (!args.options.save) {
+            return appInfo;
+        }
+        const filePath = '.m365rc.json';
+        if (this.verbose) {
+            await logger.logToStderr(`Saving Azure AD app registration information to the ${filePath} file...`);
+        }
+        let m365rc = {};
+        if (fs.existsSync(filePath)) {
+            if (this.debug) {
+                await logger.logToStderr(`Reading existing ${filePath}...`);
             }
-            m365rc.apps.push({
-                appId: appInfo.appId,
-                name: this.appName
-            });
             try {
-                fs.writeFileSync(filePath, JSON.stringify(m365rc, null, 2));
+                const fileContents = fs.readFileSync(filePath, 'utf8');
+                if (fileContents) {
+                    m365rc = JSON.parse(fileContents);
+                }
             }
             catch (e) {
-                logger.logToStderr(`Error writing ${filePath}: ${e}. Please add app info to ${filePath} manually.`);
+                await logger.logToStderr(`Error reading ${filePath}: ${e}. Please add app info to ${filePath} manually.`);
+                return Promise.resolve(appInfo);
             }
-            return appInfo;
+        }
+        if (!m365rc.apps) {
+            m365rc.apps = [];
+        }
+        m365rc.apps.push({
+            appId: appInfo.appId,
+            name: this.appName
         });
+        try {
+            fs.writeFileSync(filePath, JSON.stringify(m365rc, null, 2));
+        }
+        catch (e) {
+            await logger.logToStderr(`Error writing ${filePath}: ${e}. Please add app info to ${filePath} manually.`);
+        }
+        return Promise.resolve(appInfo);
     }
     translatePlatformToType(platform) {
         if (platform === 'publicClient') {
@@ -677,7 +635,7 @@ class AadAppAddCommand extends GraphCommand_1.default {
         return platform.charAt(0).toUpperCase() + platform.substring(1);
     }
 }
-_AadAppAddCommand_instances = new WeakSet(), _AadAppAddCommand_initTelemetry = function _AadAppAddCommand_initTelemetry() {
+_a = AadAppAddCommand, _AadAppAddCommand_instances = new WeakSet(), _AadAppAddCommand_initTelemetry = function _AadAppAddCommand_initTelemetry() {
     this.telemetry.push((args) => {
         Object.assign(this.telemetryProperties, {
             apis: typeof args.options.apisDelegated !== 'undefined',
@@ -706,7 +664,7 @@ _AadAppAddCommand_instances = new WeakSet(), _AadAppAddCommand_initTelemetry = f
         option: '-r, --redirectUris [redirectUris]'
     }, {
         option: '-p, --platform [platform]',
-        autocomplete: AadAppAddCommand.aadApplicationPlatform
+        autocomplete: _a.aadApplicationPlatform
     }, {
         option: '--implicitFlow'
     }, {
@@ -721,7 +679,7 @@ _AadAppAddCommand_instances = new WeakSet(), _AadAppAddCommand_initTelemetry = f
         option: '--scopeName [scopeName]'
     }, {
         option: '--scopeConsentBy [scopeConsentBy]',
-        autocomplete: AadAppAddCommand.aadAppScopeConsentBy
+        autocomplete: _a.aadAppScopeConsentBy
     }, {
         option: '--scopeAdminConsentDisplayName [scopeAdminConsentDisplayName]'
     }, {
@@ -740,10 +698,10 @@ _AadAppAddCommand_instances = new WeakSet(), _AadAppAddCommand_initTelemetry = f
         option: '--grantAdminConsent'
     });
 }, _AadAppAddCommand_initValidators = function _AadAppAddCommand_initValidators() {
-    this.validators.push((args) => __awaiter(this, void 0, void 0, function* () {
+    this.validators.push(async (args) => {
         if (args.options.platform &&
-            AadAppAddCommand.aadApplicationPlatform.indexOf(args.options.platform) < 0) {
-            return `${args.options.platform} is not a valid value for platform. Allowed values are ${AadAppAddCommand.aadApplicationPlatform.join(', ')}`;
+            _a.aadApplicationPlatform.indexOf(args.options.platform) < 0) {
+            return `${args.options.platform} is not a valid value for platform. Allowed values are ${_a.aadApplicationPlatform.join(', ')}`;
         }
         if (args.options.redirectUris && !args.options.platform) {
             return `When you specify redirectUris you also need to specify platform`;
@@ -769,8 +727,8 @@ _AadAppAddCommand_instances = new WeakSet(), _AadAppAddCommand_initTelemetry = f
             }
         }
         if (args.options.scopeConsentBy &&
-            AadAppAddCommand.aadAppScopeConsentBy.indexOf(args.options.scopeConsentBy) < 0) {
-            return `${args.options.scopeConsentBy} is not a valid value for scopeConsentBy. Allowed values are ${AadAppAddCommand.aadAppScopeConsentBy.join(', ')}`;
+            _a.aadAppScopeConsentBy.indexOf(args.options.scopeConsentBy) < 0) {
+            return `${args.options.scopeConsentBy} is not a valid value for scopeConsentBy. Allowed values are ${_a.aadAppScopeConsentBy.join(', ')}`;
         }
         if (args.options.manifest) {
             try {
@@ -784,11 +742,11 @@ _AadAppAddCommand_instances = new WeakSet(), _AadAppAddCommand_initTelemetry = f
             }
         }
         return true;
-    }));
+    });
 }, _AadAppAddCommand_initOptionSets = function _AadAppAddCommand_initOptionSets() {
     this.optionSets.push({ options: ['name', 'manifest'] });
 };
 AadAppAddCommand.aadApplicationPlatform = ['spa', 'web', 'publicClient'];
 AadAppAddCommand.aadAppScopeConsentBy = ['admins', 'adminsAndUsers'];
-module.exports = new AadAppAddCommand();
+export default new AadAppAddCommand();
 //# sourceMappingURL=app-add.js.map