@pnp/cli-microsoft365 9.1.0-beta.94ae9ed → 9.1.0-beta.a781c51

package/dist/m365/spo/commands/site/site-admin-remove.js

@@ -0,0 +1,194 @@
+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 _SpoSiteAdminRemoveCommand_instances, _SpoSiteAdminRemoveCommand_initTelemetry, _SpoSiteAdminRemoveCommand_initOptions, _SpoSiteAdminRemoveCommand_initValidators, _SpoSiteAdminRemoveCommand_initOptionSets, _SpoSiteAdminRemoveCommand_initTypes;
+import { cli } from '../../../../cli/cli.js';
+import request from '../../../../request.js';
+import { entraGroup } from '../../../../utils/entraGroup.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { spo } from '../../../../utils/spo.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+class SpoSiteAdminRemoveCommand extends SpoCommand {
+    get name() {
+        return commands.SITE_ADMIN_REMOVE;
+    }
+    get description() {
+        return 'Removes a user or group as site collection administrator';
+    }
+    constructor() {
+        super();
+        _SpoSiteAdminRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminRemoveCommand_instances, "m", _SpoSiteAdminRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminRemoveCommand_instances, "m", _SpoSiteAdminRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminRemoveCommand_instances, "m", _SpoSiteAdminRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminRemoveCommand_instances, "m", _SpoSiteAdminRemoveCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoSiteAdminRemoveCommand_instances, "m", _SpoSiteAdminRemoveCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            if (!args.options.force) {
+                const principalToDelete = args.options.groupId || args.options.groupName ? 'group' : 'user';
+                const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove specified ${principalToDelete} from the site administrators list ${args.options.siteUrl}?` });
+                if (!result) {
+                    return;
+                }
+            }
+            const loginNameToRemove = await this.getCorrectLoginName(args.options);
+            if (args.options.asAdmin) {
+                await this.callActionAsAdmin(logger, args, loginNameToRemove);
+                return;
+            }
+            await this.callAction(logger, args, loginNameToRemove);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async callActionAsAdmin(logger, args, loginNameToRemove) {
+        if (this.verbose) {
+            await logger.logToStderr('Removing site administrator as an administrator...');
+        }
+        const adminUrl = await spo.getSpoAdminUrl(logger, this.debug);
+        const siteId = await this.getSiteId(args.options.siteUrl, logger);
+        const primaryAdminLoginName = await spo.getPrimaryAdminLoginNameAsAdmin(adminUrl, siteId, logger, this.verbose);
+        if (loginNameToRemove === primaryAdminLoginName) {
+            throw 'You cannot remove the primary site collection administrator.';
+        }
+        const existingAdmins = await this.getSiteAdmins(adminUrl, siteId);
+        const adminsToSet = existingAdmins.filter(u => u.loginName.toLowerCase() !== loginNameToRemove.toLowerCase());
+        await this.setSiteAdminsAsAdmin(adminUrl, siteId, adminsToSet);
+    }
+    async getSiteId(siteUrl, logger) {
+        const siteGraphId = await spo.getSiteId(siteUrl, logger, this.verbose);
+        const match = siteGraphId.match(/,([a-f0-9\-]{36}),/i);
+        if (!match) {
+            throw `Site with URL ${siteUrl} not found`;
+        }
+        return match[1];
+    }
+    async getSiteAdmins(adminUrl, siteId) {
+        const requestOptions = {
+            url: `${adminUrl}/_api/SPO.Tenant/GetSiteAdministrators?siteId='${siteId}'`,
+            headers: {
+                accept: 'application/json;odata=nometadata',
+                'content-type': 'application/json;charset=utf-8'
+            },
+            responseType: 'json'
+        };
+        const response = await request.post(requestOptions);
+        return response.value;
+    }
+    async getCorrectLoginName(options) {
+        if (options.userId || options.userName) {
+            const userPrincipalName = options.userName ? options.userName : await entraUser.getUpnByUserId(options.userId);
+            if (userPrincipalName) {
+                return `i:0#.f|membership|${userPrincipalName}`;
+            }
+            throw 'User not found.';
+        }
+        else {
+            const group = options.groupId ? await entraGroup.getGroupById(options.groupId) : await entraGroup.getGroupByDisplayName(options.groupName);
+            //for entra groups, M365 groups have an associated email and security groups don't
+            if (group?.mail) {
+                //M365 group is prefixed with c:0o.c|federateddirectoryclaimprovider
+                return `c:0o.c|federateddirectoryclaimprovider|${group.id}`;
+            }
+            else {
+                //security group is prefixed with c:0t.c|tenant
+                return `c:0t.c|tenant|${group?.id}`;
+            }
+        }
+    }
+    async setSiteAdminsAsAdmin(adminUrl, siteId, admins) {
+        const requestOptions = {
+            url: `${adminUrl}/_api/SPOInternalUseOnly.Tenant/SetSiteSecondaryAdministrators`,
+            headers: {
+                accept: 'application/json;odata=nometadata',
+                'content-type': 'application/json;charset=utf-8'
+            },
+            data: {
+                secondaryAdministratorsFieldsData: {
+                    siteId: siteId,
+                    secondaryAdministratorLoginNames: admins.map(u => u.loginName)
+                }
+            },
+            responseType: 'json'
+        };
+        await request.post(requestOptions);
+    }
+    async callAction(logger, args, loginNameToRemove) {
+        if (this.verbose) {
+            await logger.logToStderr('Removing site administrator...');
+        }
+        const primaryOwnerLogin = await spo.getPrimaryOwnerLoginFromSite(args.options.siteUrl, logger, this.verbose);
+        if (loginNameToRemove === primaryOwnerLogin) {
+            throw 'You cannot remove the primary site collection administrator.';
+        }
+        const requestOptions = {
+            url: `${args.options.siteUrl}/_api/web/siteusers('${formatting.encodeQueryParameter(loginNameToRemove)}')`,
+            headers: {
+                'accept': 'application/json',
+                'X-Http-Method': 'MERGE',
+                'If-Match': '*'
+            },
+            data: { IsSiteAdmin: false },
+            responseType: 'json'
+        };
+        await request.post(requestOptions);
+    }
+}
+_SpoSiteAdminRemoveCommand_instances = new WeakSet(), _SpoSiteAdminRemoveCommand_initTelemetry = function _SpoSiteAdminRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            userId: typeof args.options.userId !== 'undefined',
+            userName: typeof args.options.userName !== 'undefined',
+            groupId: typeof args.options.groupId !== 'undefined',
+            groupName: typeof args.options.groupName !== 'undefined',
+            force: !!args.options.force,
+            asAdmin: !!args.options.asAdmin
+        });
+    });
+}, _SpoSiteAdminRemoveCommand_initOptions = function _SpoSiteAdminRemoveCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --siteUrl <siteUrl>'
+    }, {
+        option: '--userId [userId]'
+    }, {
+        option: '--userName [userName]'
+    }, {
+        option: '--groupId [groupId]'
+    }, {
+        option: '--groupName [groupName]'
+    }, {
+        option: '--asAdmin'
+    }, {
+        option: '-f, --force'
+    });
+}, _SpoSiteAdminRemoveCommand_initValidators = function _SpoSiteAdminRemoveCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.userId &&
+            !validation.isValidGuid(args.options.userId)) {
+            return `${args.options.userId} is not a valid GUID`;
+        }
+        if (args.options.userName && !validation.isValidUserPrincipalName(args.options.userName)) {
+            return `${args.options.userName} is not a valid userName`;
+        }
+        if (args.options.groupId &&
+            !validation.isValidGuid(args.options.groupId)) {
+            return `${args.options.groupId} is not a valid GUID`;
+        }
+        return validation.isValidSharePointUrl(args.options.siteUrl);
+    });
+}, _SpoSiteAdminRemoveCommand_initOptionSets = function _SpoSiteAdminRemoveCommand_initOptionSets() {
+    this.optionSets.push({ options: ['userId', 'userName', 'groupId', 'groupName'] });
+}, _SpoSiteAdminRemoveCommand_initTypes = function _SpoSiteAdminRemoveCommand_initTypes() {
+    this.types.string.push('siteUrl', 'userId', 'userName', 'groupId', 'groupName');
+    this.types.boolean.push('force', 'asAdmin');
+};
+export default new SpoSiteAdminRemoveCommand();
+//# sourceMappingURL=site-admin-remove.js.map

package/dist/m365/spo/commands/site/site-sharingpermission-set.js

@@ -0,0 +1,68 @@
+import SpoCommand from '../../../base/SpoCommand.js';
+import { globalOptionsZod } from '../../../../Command.js';
+import { z } from 'zod';
+import { zod } from '../../../../utils/zod.js';
+import commands from '../../commands.js';
+import { validation } from '../../../../utils/validation.js';
+import request from '../../../../request.js';
+const options = globalOptionsZod
+    .extend({
+    siteUrl: zod.alias('u', z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, url => ({
+        message: `'${url}' is not a valid SharePoint Online site URL.`
+    }))),
+    capability: z.enum(['full', 'limited', 'ownersOnly'])
+})
+    .strict();
+class SpoSiteSharingPermissionSetCommand extends SpoCommand {
+    get name() {
+        return commands.SITE_SHARINGPERMISSION_SET;
+    }
+    get description() {
+        return 'Controls how a site and its components can be shared';
+    }
+    get schema() {
+        return options;
+    }
+    async commandAction(logger, args) {
+        try {
+            if (this.verbose) {
+                await logger.logToStderr(`Updating sharing permissions for site '${args.options.siteUrl}'...`);
+            }
+            const { capability } = args.options;
+            if (this.verbose) {
+                await logger.logToStderr(`Updating site sharing permissions...`);
+            }
+            const requestOptionsWeb = {
+                url: `${args.options.siteUrl}/_api/Web`,
+                headers: {
+                    accept: 'application/json;odata=nometadata'
+                },
+                responseType: 'json',
+                data: {
+                    MembersCanShare: capability === 'full' || capability === 'limited'
+                }
+            };
+            await request.patch(requestOptionsWeb);
+            if (this.verbose) {
+                await logger.logToStderr(`Updating associated member group sharing permissions...`);
+            }
+            const requestOptionsMemberGroup = {
+                url: `${args.options.siteUrl}/_api/Web/AssociatedMemberGroup`,
+                headers: {
+                    accept: 'application/json;odata=nometadata'
+                },
+                responseType: 'json',
+                data: {
+                    AllowMembersEditMembership: capability === 'full'
+                }
+            };
+            await request.patch(requestOptionsMemberGroup);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new SpoSiteSharingPermissionSetCommand();
+//# sourceMappingURL=site-sharingpermission-set.js.map

package/dist/m365/spo/commands.js

@@ -247,6 +247,7 @@ export default {
     SITE_ADD: `${prefix} site add`,
     SITE_ADMIN_ADD: `${prefix} site admin add`,
     SITE_ADMIN_LIST: `${prefix} site admin list`,
+    SITE_ADMIN_REMOVE: `${prefix} site admin remove`,
     SITE_APPCATALOG_ADD: `${prefix} site appcatalog add`,
     SITE_APPCATALOG_LIST: `${prefix} site appcatalog list`,
     SITE_APPCATALOG_REMOVE: `${prefix} site appcatalog remove`,
@@ -272,6 +273,7 @@ export default {
     SITE_REMOVE: `${prefix} site remove`,
     SITE_RENAME: `${prefix} site rename`,
     SITE_SET: `${prefix} site set`,
+    SITE_SHARINGPERMISSION_SET: `${prefix} site sharingpermission set`,
     SITE_CHROME_SET: `${prefix} site chrome set`,
     SITEDESIGN_ADD: `${prefix} sitedesign add`,
     SITEDESIGN_APPLY: `${prefix} sitedesign apply`,

package/dist/m365/teams/MeetingTranscript.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=MeetingTranscript.js.map

package/dist/m365/teams/commands/meeting/meeting-transcript-get.js

@@ -0,0 +1,152 @@
+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 _TeamsMeetingTranscriptGetCommand_instances, _TeamsMeetingTranscriptGetCommand_initTelemetry, _TeamsMeetingTranscriptGetCommand_initOptions, _TeamsMeetingTranscriptGetCommand_initValidators, _TeamsMeetingTranscriptGetCommand_initOptionSets;
+import auth from '../../../../Auth.js';
+import request from '../../../../request.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { accessToken } from '../../../../utils/accessToken.js';
+import { validation } from '../../../../utils/validation.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import fs from 'fs';
+import path from 'path';
+class TeamsMeetingTranscriptGetCommand extends GraphCommand {
+    get name() {
+        return commands.MEETING_TRANSCRIPT_GET;
+    }
+    get description() {
+        return 'Downloads a transcript for a given meeting';
+    }
+    constructor() {
+        super();
+        _TeamsMeetingTranscriptGetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _TeamsMeetingTranscriptGetCommand_instances, "m", _TeamsMeetingTranscriptGetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingTranscriptGetCommand_instances, "m", _TeamsMeetingTranscriptGetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingTranscriptGetCommand_instances, "m", _TeamsMeetingTranscriptGetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingTranscriptGetCommand_instances, "m", _TeamsMeetingTranscriptGetCommand_initOptionSets).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            const isAppOnlyAccessToken = accessToken.isAppOnlyAccessToken(auth.connection.accessTokens[this.resource].accessToken);
+            if (this.verbose) {
+                await logger.logToStderr(`Retrieving transcript for the given meeting...`);
+            }
+            let requestUrl = `${this.resource}/beta/`;
+            if (isAppOnlyAccessToken) {
+                if (!args.options.userId && !args.options.userName && !args.options.email) {
+                    throw `The option 'userId', 'userName' or 'email' is required when retrieving meeting transcript using app only permissions`;
+                }
+                requestUrl += 'users/';
+                if (args.options.userId) {
+                    requestUrl += args.options.userId;
+                }
+                else if (args.options.userName) {
+                    requestUrl += args.options.userName;
+                }
+                else if (args.options.email) {
+                    if (this.verbose) {
+                        await logger.logToStderr(`Getting user ID for user with email '${args.options.email}'.`);
+                    }
+                    const userId = await entraUser.getUserIdByEmail(args.options.email);
+                    requestUrl += userId;
+                }
+            }
+            else {
+                if (args.options.userId || args.options.userName || args.options.email) {
+                    throw `The options 'userId', 'userName', and 'email' cannot be used while retrieving meeting transcript using delegated permissions`;
+                }
+                requestUrl += `me`;
+            }
+            requestUrl += `/onlineMeetings/${args.options.meetingId}/transcripts/${args.options.id}`;
+            if (args.options.outputFile) {
+                requestUrl += '/content?$format=text/vtt';
+            }
+            const requestOptions = {
+                url: requestUrl,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: args.options.outputFile ? 'stream' : 'json'
+            };
+            const meetingTranscript = await request.get(requestOptions);
+            if (meetingTranscript) {
+                if (args.options.outputFile) {
+                    // Not possible to use async/await for this promise
+                    await new Promise((resolve, reject) => {
+                        const writer = fs.createWriteStream(args.options.outputFile);
+                        meetingTranscript.data.pipe(writer);
+                        writer.on('error', err => {
+                            reject(err);
+                        });
+                        writer.on('close', async () => {
+                            const filePath = args.options.outputFile;
+                            if (this.verbose) {
+                                await logger.logToStderr(`File saved to path ${filePath}`);
+                            }
+                            return resolve();
+                        });
+                    });
+                }
+                else {
+                    await logger.log(meetingTranscript);
+                }
+            }
+            else {
+                throw `The specified meeting transcript was not found`;
+            }
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+_TeamsMeetingTranscriptGetCommand_instances = new WeakSet(), _TeamsMeetingTranscriptGetCommand_initTelemetry = function _TeamsMeetingTranscriptGetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            userId: typeof args.options.userId !== 'undefined',
+            userName: typeof args.options.userName !== 'undefined',
+            email: typeof args.options.email !== 'undefined',
+            outputFile: typeof args.options.outputFile !== 'undefined'
+        });
+    });
+}, _TeamsMeetingTranscriptGetCommand_initOptions = function _TeamsMeetingTranscriptGetCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --userId [userId]'
+    }, {
+        option: '-n, --userName [userName]'
+    }, {
+        option: '--email [email]'
+    }, {
+        option: '-m, --meetingId <meetingId>'
+    }, {
+        option: '-i, --id <id>'
+    }, {
+        option: '-f, --outputFile [outputFile]'
+    });
+}, _TeamsMeetingTranscriptGetCommand_initValidators = function _TeamsMeetingTranscriptGetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.userId && !validation.isValidGuid(args.options.userId)) {
+            return `${args.options.userId} is not a valid Guid`;
+        }
+        if (args.options.userName && !validation.isValidUserPrincipalName(args.options.userName)) {
+            return `${args.options.userName} is not a valid user principal name (UPN)`;
+        }
+        if (args.options.email && !validation.isValidUserPrincipalName(args.options.email)) {
+            return `${args.options.email} is not a valid email`;
+        }
+        if (args.options.outputFile && !fs.existsSync(path.dirname(args.options.outputFile))) {
+            return 'Specified path where to save the file does not exits';
+        }
+        return true;
+    });
+}, _TeamsMeetingTranscriptGetCommand_initOptionSets = function _TeamsMeetingTranscriptGetCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['userId', 'userName', 'email'],
+        runsWhen: (args) => args.options.userId || args.options.userName || args.options.email
+    });
+};
+export default new TeamsMeetingTranscriptGetCommand();
+//# sourceMappingURL=meeting-transcript-get.js.map

package/dist/m365/teams/commands.js

@@ -32,6 +32,7 @@ export default {
     MEETING_LIST: `${prefix} meeting list`,
     MEETING_ATTENDANCEREPORT_GET: `${prefix} meeting attendancereport get`,
     MEETING_ATTENDANCEREPORT_LIST: `${prefix} meeting attendancereport list`,
+    MEETING_TRANSCRIPT_GET: `${prefix} meeting transcript get`,
     MEETING_TRANSCRIPT_LIST: `${prefix} meeting transcript list`,
     MEMBERSETTINGS_LIST: `${prefix} membersettings list`,
     MEMBERSETTINGS_SET: `${prefix} membersettings set`,

package/dist/m365/viva/commands/engage/Community.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Community.js.map

package/dist/m365/viva/commands/engage/engage-community-list.js

@@ -0,0 +1,28 @@
+import { odata } from '../../../../utils/odata.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class VivaEngageCommunityListCommand extends GraphCommand {
+    get name() {
+        return commands.ENGAGE_COMMUNITY_LIST;
+    }
+    get description() {
+        return 'Lists all Viva Engage communities';
+    }
+    defaultProperties() {
+        return ['id', 'displayName', 'privacy'];
+    }
+    async commandAction(logger) {
+        if (this.verbose) {
+            await logger.logToStderr('Getting all Viva Engage communities...');
+        }
+        try {
+            const results = await odata.getAllItems(`${this.resource}/v1.0/employeeExperience/communities`);
+            await logger.log(results);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new VivaEngageCommunityListCommand();
+//# sourceMappingURL=engage-community-list.js.map

package/dist/m365/viva/commands.js

@@ -3,6 +3,7 @@ export default {
     CONNECTIONS_APP_CREATE: `${prefix} connections app create`,
     ENGAGE_COMMUNITY_ADD: `${prefix} engage community add`,
     ENGAGE_COMMUNITY_GET: `${prefix} engage community get`,
+    ENGAGE_COMMUNITY_LIST: `${prefix} engage community list`,
     ENGAGE_GROUP_LIST: `${prefix} engage group list`,
     ENGAGE_GROUP_USER_ADD: `${prefix} engage group user add`,
     ENGAGE_GROUP_USER_REMOVE: `${prefix} engage group user remove`,

package/dist/request.js

@@ -4,6 +4,7 @@ import auth, { Auth } from './Auth.js';
 import { app } from './utils/app.js';
 import { formatting } from './utils/formatting.js';
 import { timings } from './cli/timings.js';
+import { timersUtil } from './utils/timersUtil.js';
 class Request {
     set debug(debug) {
         // if the value to set is the same as current value return early to avoid
@@ -125,76 +126,60 @@ class Request {
         options.method = 'HEAD';
         return this.execute(options);
     }
-    execute(options, resolve, reject) {
+    async execute(options) {
         const start = process.hrtime.bigint();
         if (!this._logger) {
-            return Promise.reject('Logger not set on the request object');
+            throw 'Logger not set on the request object';
         }
         this.updateRequestForCloudType(options, auth.connection.cloudType);
-        return new Promise((_resolve, _reject) => {
-            (() => {
-                if (options.headers && options.headers['x-anonymous']) {
-                    return Promise.resolve('');
-                }
-                else {
-                    const url = options.headers && options.headers['x-resource'] ? options.headers['x-resource'] : options.url;
-                    const resource = Auth.getResourceFromUrl(url);
-                    return auth.ensureAccessToken(resource, this._logger, this._debug);
-                }
-            })()
-                .then((accessToken) => {
-                if (options.headers) {
-                    if (options.headers['x-anonymous']) {
-                        delete options.headers['x-anonymous'];
-                    }
-                    if (options.headers['x-resource']) {
-                        delete options.headers['x-resource'];
-                    }
-                    if (accessToken !== '') {
-                        options.headers.authorization = `Bearer ${accessToken}`;
-                    }
-                }
-                const proxyUrl = process.env.HTTP_PROXY || process.env.HTTPS_PROXY;
-                if (proxyUrl) {
-                    options.proxy = this.createProxyConfigFromUrl(proxyUrl);
+        try {
+            let accessToken = '';
+            if (options.headers && options.headers['x-anonymous']) {
+                accessToken = '';
+            }
+            else {
+                const url = options.headers && options.headers['x-resource'] ? options.headers['x-resource'] : options.url;
+                const resource = Auth.getResourceFromUrl(url);
+                accessToken = await auth.ensureAccessToken(resource, this._logger, this._debug);
+            }
+            if (options.headers) {
+                if (options.headers['x-anonymous']) {
+                    delete options.headers['x-anonymous'];
                 }
-                return this.req(options);
-            })
-                .then((res) => {
-                if (resolve) {
-                    resolve((options.responseType === 'stream' || options.fullResponse) ? res : res.data);
+                if (options.headers['x-resource']) {
+                    delete options.headers['x-resource'];
                 }
-                else {
-                    const end = process.hrtime.bigint();
-                    timings.api.push(Number(end - start));
-                    _resolve((options.responseType === 'stream' || options.fullResponse) ? res : res.data);
+                if (accessToken !== '') {
+                    options.headers.authorization = `Bearer ${accessToken}`;
                 }
-            }, async (error) => {
-                if (error && error.response &&
-                    (error.response.status === 429 ||
-                        error.response.status === 503)) {
-                    let retryAfter = parseInt(error.response.headers['retry-after'] || '10');
-                    if (isNaN(retryAfter)) {
-                        retryAfter = 10;
-                    }
-                    if (this._debug) {
-                        await this._logger.log(`Request throttled. Waiting ${retryAfter}sec before retrying...`);
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                    setTimeout(async () => { this.execute(options, resolve || _resolve, reject || _reject); }, retryAfter * 1000);
+            }
+            const proxyUrl = process.env.HTTP_PROXY || process.env.HTTPS_PROXY;
+            if (proxyUrl) {
+                options.proxy = this.createProxyConfigFromUrl(proxyUrl);
+            }
+            const res = await this.req(options);
+            const end = process.hrtime.bigint();
+            timings.api.push(Number(end - start));
+            return options.responseType === 'stream' || options.fullResponse ?
+                res :
+                res.data;
+        }
+        catch (error) {
+            const end = process.hrtime.bigint();
+            timings.api.push(Number(end - start));
+            if (error && error.response && (error.response.status === 429 || error.response.status === 503)) {
+                let retryAfter = parseInt(error.response.headers['retry-after'] || '10');
+                if (isNaN(retryAfter)) {
+                    retryAfter = 10;
                 }
-                else {
-                    if (reject) {
-                        reject(error);
-                    }
-                    else {
-                        const end = process.hrtime.bigint();
-                        timings.api.push(Number(end - start));
-                        _reject(error);
-                    }
+                if (this._debug) {
+                    await this._logger.log(`Request throttled. Waiting ${retryAfter} sec before retrying...`);
                 }
-            });
-        });
+                await timersUtil.setTimeout(retryAfter * 1000);
+                return this.execute(options);
+            }
+            throw error;
+        }
     }
     updateRequestForCloudType(options, cloudType) {
         const url = new URL(options.url);