@pnp/cli-microsoft365 8.1.0-beta.3dec9fa → 8.1.0-beta.96dc207

package/dist/m365/spo/commands/tenant/tenant-commandset-get.js

@@ -3,7 +3,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _SpoTenantCommandSetGetCommand_instances, _SpoTenantCommandSetGetCommand_initTelemetry, _SpoTenantCommandSetGetCommand_initOptions, _SpoTenantCommandSetGetCommand_initValidators, _SpoTenantCommandSetGetCommand_initOptionSets;
+var _SpoTenantCommandSetGetCommand_instances, _SpoTenantCommandSetGetCommand_initTelemetry, _SpoTenantCommandSetGetCommand_initOptions, _SpoTenantCommandSetGetCommand_initValidators, _SpoTenantCommandSetGetCommand_initOptionSets, _SpoTenantCommandSetGetCommand_initTypes;
 import { cli } from '../../../../cli/cli.js';
 import { CommandError } from '../../../../Command.js';
 import request from '../../../../request.js';
@@ -27,6 +27,7 @@ class SpoTenantCommandSetGetCommand extends SpoCommand {
         __classPrivateFieldGet(this, _SpoTenantCommandSetGetCommand_instances, "m", _SpoTenantCommandSetGetCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoTenantCommandSetGetCommand_instances, "m", _SpoTenantCommandSetGetCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _SpoTenantCommandSetGetCommand_instances, "m", _SpoTenantCommandSetGetCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoTenantCommandSetGetCommand_instances, "m", _SpoTenantCommandSetGetCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
         const appCatalogUrl = await spo.getTenantAppCatalogUrl(logger, this.debug);
@@ -47,7 +48,7 @@ class SpoTenantCommandSetGetCommand extends SpoCommand {
         const reqOptions = {
             url: `${appCatalogUrl}/_api/web/GetList('${formatting.encodeQueryParameter(listServerRelativeUrl)}')/items?$filter=${filter}`,
             headers: {
-                'accept': 'application/json;odata=nometadata'
+                accept: 'application/json;odata=nometadata'
             },
             responseType: 'json'
         };
@@ -55,13 +56,20 @@ class SpoTenantCommandSetGetCommand extends SpoCommand {
             const listItemInstances = await request.get(reqOptions);
             if (listItemInstances?.value.length > 0) {
                 listItemInstances.value.forEach(v => delete v['ID']);
+                let listItemInstance;
                 if (listItemInstances.value.length > 1) {
                     const resultAsKeyValuePair = formatting.convertArrayToHashTable('Id', listItemInstances.value);
-                    const result = await cli.handleMultipleResultsFound(`Multiple ListView Command Sets with ${args.options.title || args.options.clientSideComponentId} were found.`, resultAsKeyValuePair);
-                    await logger.log(result);
+                    listItemInstance = await cli.handleMultipleResultsFound(`Multiple ListView Command Sets with ${args.options.title || args.options.clientSideComponentId} were found.`, resultAsKeyValuePair);
                 }
                 else {
-                    await logger.log(listItemInstances.value[0]);
+                    listItemInstance = listItemInstances.value[0];
+                }
+                if (!args.options.tenantWideExtensionComponentProperties) {
+                    await logger.log(listItemInstance);
+                }
+                else {
+                    const properties = formatting.tryParseJson(listItemInstance.TenantWideExtensionComponentProperties);
+                    await logger.log(properties);
                 }
             }
             else {
@@ -78,7 +86,8 @@ _SpoTenantCommandSetGetCommand_instances = new WeakSet(), _SpoTenantCommandSetGe
         Object.assign(this.telemetryProperties, {
             title: typeof args.options.title !== 'undefined',
             id: typeof args.options.id !== 'undefined',
-            clientSideComponentId: typeof args.options.clientSideComponentId !== 'undefined'
+            clientSideComponentId: typeof args.options.clientSideComponentId !== 'undefined',
+            tenantWideExtensionComponentProperties: !!args.options.tenantWideExtensionComponentProperties
         });
     });
 }, _SpoTenantCommandSetGetCommand_initOptions = function _SpoTenantCommandSetGetCommand_initOptions() {
@@ -88,6 +97,8 @@ _SpoTenantCommandSetGetCommand_instances = new WeakSet(), _SpoTenantCommandSetGe
         option: '-i, --id [id]'
     }, {
         option: '-c, --clientSideComponentId  [clientSideComponentId]'
+    }, {
+        option: '-p, --tenantWideExtensionComponentProperties'
     });
 }, _SpoTenantCommandSetGetCommand_initValidators = function _SpoTenantCommandSetGetCommand_initValidators() {
     this.validators.push(async (args) => {
@@ -101,6 +112,9 @@ _SpoTenantCommandSetGetCommand_instances = new WeakSet(), _SpoTenantCommandSetGe
     });
 }, _SpoTenantCommandSetGetCommand_initOptionSets = function _SpoTenantCommandSetGetCommand_initOptionSets() {
     this.optionSets.push({ options: ['title', 'id', 'clientSideComponentId'] });
+}, _SpoTenantCommandSetGetCommand_initTypes = function _SpoTenantCommandSetGetCommand_initTypes() {
+    this.types.string.push('title', 'id', 'clientSideComponentId');
+    this.types.boolean.push('tenantWideExtensionComponentProperties');
 };
 export default new SpoTenantCommandSetGetCommand();
 //# sourceMappingURL=tenant-commandset-get.js.map

package/dist/m365/spo/commands.js

@@ -100,6 +100,8 @@ export default {
     FOLDER_ROLEASSIGNMENT_ADD: `${prefix} folder roleassignment add`,
     FOLDER_ROLEINHERITANCE_BREAK: `${prefix} folder roleinheritance break`,
     FOLDER_ROLEINHERITANCE_RESET: `${prefix} folder roleinheritance reset`,
+    FOLDER_SHARINGLINK_GET: `${prefix} folder sharinglink get`,
+    FOLDER_SHARINGLINK_LIST: `${prefix} folder sharinglink list`,
     GET: `${prefix} get`,
     GROUP_ADD: `${prefix} group add`,
     GROUP_GET: `${prefix} group get`,

package/dist/m365/teams/commands/message/message-restore.js

@@ -0,0 +1,106 @@
+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 _TeamsMessageRestoreCommand_instances, _TeamsMessageRestoreCommand_initTelemetry, _TeamsMessageRestoreCommand_initOptions, _TeamsMessageRestoreCommand_initValidators, _TeamsMessageRestoreCommand_initOptionSets, _TeamsMessageRestoreCommand_initTypes;
+import request from '../../../../request.js';
+import { validation } from '../../../../utils/validation.js';
+import commands from '../../commands.js';
+import DelegatedGraphCommand from '../../../base/DelegatedGraphCommand.js';
+import { teams } from '../../../../utils/teams.js';
+class TeamsMessageRestoreCommand extends DelegatedGraphCommand {
+    get name() {
+        return commands.MESSAGE_RESTORE;
+    }
+    get description() {
+        return 'Restores a deleted message from a channel in a Microsoft Teams team';
+    }
+    constructor() {
+        super();
+        _TeamsMessageRestoreCommand_instances.add(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            if (this.verbose) {
+                await logger.logToStderr(`Restoring deleted message '${args.options.id}' from channel '${args.options.channelId || args.options.channelName}' in the Microsoft Teams team '${args.options.teamId || args.options.teamName}'.`);
+            }
+            const teamId = await this.getTeamId(args.options, logger);
+            const channelId = await this.getChannelId(args.options, teamId, logger);
+            const requestOptions = {
+                url: `${this.resource}/v1.0/teams/${teamId}/channels/${channelId}/messages/${args.options.id}/undoSoftDelete`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json'
+            };
+            await request.post(requestOptions);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getTeamId(options, logger) {
+        if (options.teamId) {
+            return options.teamId;
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Getting the Team ID.`);
+        }
+        const groupId = await teams.getTeamIdByDisplayName(options.teamName);
+        return groupId;
+    }
+    async getChannelId(options, teamId, logger) {
+        if (options.channelId) {
+            return options.channelId;
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Getting the channel ID.`);
+        }
+        const channelId = await teams.getChannelIdByDisplayName(teamId, options.channelName);
+        return channelId;
+    }
+}
+_TeamsMessageRestoreCommand_instances = new WeakSet(), _TeamsMessageRestoreCommand_initTelemetry = function _TeamsMessageRestoreCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            teamId: typeof args.options.teamId !== 'undefined',
+            teamName: typeof args.options.teamName !== 'undefined',
+            channelId: typeof args.options.channelId !== 'undefined',
+            channelName: typeof args.options.channelName !== 'undefined'
+        });
+    });
+}, _TeamsMessageRestoreCommand_initOptions = function _TeamsMessageRestoreCommand_initOptions() {
+    this.options.unshift({
+        option: '--teamId [teamId]'
+    }, {
+        option: '--teamName [teamName]'
+    }, {
+        option: '--channelId [channelId]'
+    }, {
+        option: '--channelName [channelName]'
+    }, {
+        option: '-i, --id <id>'
+    });
+}, _TeamsMessageRestoreCommand_initValidators = function _TeamsMessageRestoreCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.teamId && !validation.isValidGuid(args.options.teamId)) {
+            return `'${args.options.teamId}' is not a valid GUID for 'teamId'.`;
+        }
+        if (args.options.channelId && !validation.isValidTeamsChannelId(args.options.channelId)) {
+            return `'${args.options.channelId}' is not a valid ID for 'channelId'.`;
+        }
+        return true;
+    });
+}, _TeamsMessageRestoreCommand_initOptionSets = function _TeamsMessageRestoreCommand_initOptionSets() {
+    this.optionSets.push({ options: ['teamId', 'teamName'] }, { options: ['channelId', 'channelName'] });
+}, _TeamsMessageRestoreCommand_initTypes = function _TeamsMessageRestoreCommand_initTypes() {
+    this.types.string.push('teamId', 'teamName', 'channelId', 'channelName', 'id');
+};
+export default new TeamsMessageRestoreCommand();
+//# sourceMappingURL=message-restore.js.map

package/dist/m365/teams/commands.js

@@ -39,6 +39,7 @@ export default {
     MESSAGE_LIST: `${prefix} message list`,
     MESSAGE_REMOVE: `${prefix} message remove`,
     MESSAGE_REPLY_LIST: `${prefix} message reply list`,
+    MESSAGE_RESTORE: `${prefix} message restore`,
     MESSAGE_SEND: `${prefix} message send`,
     MESSAGINGSETTINGS_LIST: `${prefix} messagingsettings list`,
     MESSAGINGSETTINGS_SET: `${prefix} messagingsettings set`,

package/dist/settingsNames.js

@@ -1,6 +1,11 @@
 const settingsNames = {
     authType: 'authType',
     autoOpenLinksInBrowser: 'autoOpenLinksInBrowser',
+    clientId: 'clientId',
+    clientSecret: 'clientSecret',
+    clientCertificateFile: 'clientCertificateFile',
+    clientCertificateBase64Encoded: 'clientCertificateBase64Encoded',
+    clientCertificatePassword: 'clientCertificatePassword',
     copyDeviceCodeToClipboard: 'copyDeviceCodeToClipboard',
     csvEscape: 'csvEscape',
     csvHeader: 'csvHeader',
@@ -16,7 +21,8 @@ const settingsNames = {
     prompt: 'prompt',
     promptListPageSize: 'promptListPageSize',
     showHelpOnFailure: 'showHelpOnFailure',
-    showSpinner: 'showSpinner'
+    showSpinner: 'showSpinner',
+    tenantId: 'tenantId'
 };
 export { settingsNames };
 //# sourceMappingURL=settingsNames.js.map

package/dist/utils/drive.js

@@ -0,0 +1,61 @@
+import request from "../request.js";
+export const drive = {
+    /**
+     * Retrieves the Drive associated with the specified site and URL.
+     * @param siteId Site ID
+     * @param url Drive URL
+     * @param logger The logger object
+     * @param verbose Set for verbose logging
+     * @returns The Drive associated with the drive URL.
+     */
+    async getDriveByUrl(siteId, url, logger, verbose) {
+        if (verbose && logger) {
+            await logger.logToStderr(`Retrieving drive information for URL: ${url.href}`);
+        }
+        const requestOptions = {
+            url: `https://graph.microsoft.com/v1.0/sites/${siteId}/drives?$select=webUrl,id`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        const drives = await request.get(requestOptions);
+        const lowerCaseFolderUrl = url.href.toLowerCase();
+        const drive = drives.value
+            .sort((a, b) => b.webUrl.localeCompare(a.webUrl))
+            .find((d) => {
+            const driveUrl = d.webUrl.toLowerCase();
+            return lowerCaseFolderUrl.startsWith(driveUrl) &&
+                (driveUrl.length === lowerCaseFolderUrl.length ||
+                    lowerCaseFolderUrl[driveUrl.length] === '/');
+        });
+        if (!drive) {
+            throw new Error(`Drive '${url.href}' not found`);
+        }
+        return drive;
+    },
+    /**
+     * Retrieves the ID of a drive item (file, folder, etc.) associated with the given drive and item URL.
+     * @param drive The Drive object containing the item
+     * @param itemUrl Item URL
+     * @param logger The logger object
+     * @param verbose Set for verbose logging
+     * @returns Drive item ID
+     */
+    async getDriveItemId(drive, itemUrl, logger, verbose) {
+        const relativeItemUrl = itemUrl.href.replace(new RegExp(`${drive.webUrl}`, 'i'), '').replace(/\/+$/, '');
+        if (verbose && logger) {
+            await logger.logToStderr(`Retrieving drive item ID for URL: ${relativeItemUrl}`);
+        }
+        const requestOptions = {
+            url: `https://graph.microsoft.com/v1.0/drives/${drive.id}/root${relativeItemUrl ? `:${relativeItemUrl}` : ''}?$select=id`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        const driveItem = await request.get(requestOptions);
+        return driveItem?.id;
+    }
+};
+//# sourceMappingURL=drive.js.map

package/dist/utils/entraApp.js

@@ -0,0 +1,283 @@
+import fs from 'fs';
+import request from '../request.js';
+import { odata } from './odata.js';
+async function getCertificateBase64Encoded({ options, logger, debug }) {
+    if (options.certificateBase64Encoded) {
+        return options.certificateBase64Encoded;
+    }
+    if (debug) {
+        await logger.logToStderr(`Reading existing ${options.certificateFile}...`);
+    }
+    try {
+        return fs.readFileSync(options.certificateFile, { encoding: 'base64' });
+    }
+    catch (e) {
+        throw new Error(`Error reading certificate file: ${e}. Please add the certificate using base64 option '--certificateBase64Encoded'.`);
+    }
+}
+async function createServicePrincipal(appId) {
+    const requestOptions = {
+        url: `https://graph.microsoft.com/v1.0/myorganization/servicePrincipals`,
+        headers: {
+            'content-type': 'application/json'
+        },
+        data: {
+            appId: appId
+        },
+        responseType: 'json'
+    };
+    return request.post(requestOptions);
+}
+async function grantOAuth2Permission({ appId, resourceId, scopeName }) {
+    const grantAdminConsentApplicationRequestOptions = {
+        url: `https://graph.microsoft.com/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);
+}
+async function addRoleToServicePrincipal({ objectId, resourceId, appRoleId }) {
+    const requestOptions = {
+        url: `https://graph.microsoft.com/v1.0/myorganization/servicePrincipals/${objectId}/appRoleAssignments`,
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        responseType: 'json',
+        data: {
+            appRoleId: appRoleId,
+            principalId: objectId,
+            resourceId: resourceId
+        }
+    };
+    return request.post(requestOptions);
+}
+async function getRequiredResourceAccessForApis({ servicePrincipals, apis, scopeType, logger, debug }) {
+    if (!apis) {
+        return [];
+    }
+    const resolvedApis = [];
+    const requestedApis = apis.split(',').map(a => a.trim());
+    for (const api of requestedApis) {
+        const pos = api.lastIndexOf('/');
+        const permissionName = api.substring(pos + 1);
+        const servicePrincipalName = api.substring(0, pos);
+        if (debug) {
+            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));
+        if (!servicePrincipal) {
+            throw `Service principal ${servicePrincipalName} not found`;
+        }
+        const scopesOfType = scopeType === 'Scope' ? servicePrincipal.oauth2PermissionScopes : servicePrincipal.appRoles;
+        const permission = scopesOfType.find(scope => scope.value === permissionName);
+        if (!permission) {
+            throw `Permission ${permissionName} for service principal ${servicePrincipalName} not found`;
+        }
+        let resolvedApi = resolvedApis.find(a => a.resourceAppId === servicePrincipal.appId);
+        if (!resolvedApi) {
+            resolvedApi = {
+                resourceAppId: servicePrincipal.appId,
+                resourceAccess: []
+            };
+            resolvedApis.push(resolvedApi);
+        }
+        const resourceAccessPermission = {
+            id: permission.id,
+            type: scopeType
+        };
+        resolvedApi.resourceAccess.push(resourceAccessPermission);
+        updateAppPermissions({
+            spId: servicePrincipal.id,
+            resourceAccessPermission,
+            oAuth2PermissionValue: permission.value
+        });
+    }
+    return resolvedApis;
+}
+function updateAppPermissions({ spId, resourceAccessPermission, oAuth2PermissionValue }) {
+    // During API resolution, we store globally both app role assignments and oauth2permissions
+    // So that we'll be able to parse them during the admin consent process
+    let existingPermission = entraApp.appPermissions.find(oauth => oauth.resourceId === spId);
+    if (!existingPermission) {
+        existingPermission = {
+            resourceId: spId,
+            resourceAccess: [],
+            scope: []
+        };
+        entraApp.appPermissions.push(existingPermission);
+    }
+    if (resourceAccessPermission.type === 'Scope' && oAuth2PermissionValue && !existingPermission.scope.find(scp => scp === oAuth2PermissionValue)) {
+        existingPermission.scope.push(oAuth2PermissionValue);
+    }
+    if (!existingPermission.resourceAccess.find(res => res.id === resourceAccessPermission.id)) {
+        existingPermission.resourceAccess.push(resourceAccessPermission);
+    }
+}
+export const entraApp = {
+    appPermissions: [],
+    createAppRegistration: async ({ options, apis, logger, verbose, debug }) => {
+        const applicationInfo = {
+            displayName: options.name,
+            signInAudience: options.multitenant ? 'AzureADMultipleOrgs' : 'AzureADMyOrg'
+        };
+        if (apis.length > 0) {
+            applicationInfo.requiredResourceAccess = apis;
+        }
+        if (options.redirectUris) {
+            applicationInfo[options.platform] = {
+                redirectUris: options.redirectUris.split(',').map(u => u.trim())
+            };
+        }
+        if (options.implicitFlow) {
+            if (!applicationInfo.web) {
+                applicationInfo.web = {};
+            }
+            applicationInfo.web.implicitGrantSettings = {
+                enableAccessTokenIssuance: true,
+                enableIdTokenIssuance: true
+            };
+        }
+        if (options.certificateFile || options.certificateBase64Encoded) {
+            const certificateBase64Encoded = await getCertificateBase64Encoded({ options, logger, debug });
+            const newKeyCredential = {
+                type: 'AsymmetricX509Cert',
+                usage: 'Verify',
+                displayName: options.certificateDisplayName,
+                key: certificateBase64Encoded
+            };
+            applicationInfo.keyCredentials = [newKeyCredential];
+        }
+        if (options.allowPublicClientFlows) {
+            applicationInfo.isFallbackPublicClient = true;
+        }
+        if (verbose) {
+            await logger.logToStderr(`Creating Microsoft Entra app registration...`);
+        }
+        const createApplicationRequestOptions = {
+            url: `https://graph.microsoft.com/v1.0/myorganization/applications`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json',
+            data: applicationInfo
+        };
+        return request.post(createApplicationRequestOptions);
+    },
+    grantAdminConsent: async ({ appInfo, appPermissions, adminConsent, logger, debug }) => {
+        if (!adminConsent || appPermissions.length === 0) {
+            return appInfo;
+        }
+        const sp = await createServicePrincipal(appInfo.appId);
+        if (debug) {
+            await logger.logToStderr("Service principal created, returned object id: " + sp.id);
+        }
+        const tasks = [];
+        appPermissions.forEach(async (permission) => {
+            if (permission.scope.length > 0) {
+                tasks.push(grantOAuth2Permission({
+                    appId: sp.id,
+                    resourceId: permission.resourceId,
+                    scopeName: permission.scope.join(' ')
+                }));
+                if (debug) {
+                    await 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(addRoleToServicePrincipal({
+                    objectId: sp.id,
+                    resourceId: permission.resourceId,
+                    appRoleId: access.id
+                }));
+                if (debug) {
+                    await logger.logToStderr(`Admin consent granted for following resource ${permission.resourceId}, with application permission: ${access.id}`);
+                }
+            });
+        });
+        await Promise.all(tasks);
+        return appInfo;
+    },
+    resolveApis: async ({ options, manifest, logger, verbose, debug }) => {
+        if (!options.apisDelegated && !options.apisApplication
+            && (typeof manifest?.requiredResourceAccess === 'undefined' || manifest.requiredResourceAccess.length === 0)) {
+            return [];
+        }
+        if (verbose) {
+            await logger.logToStderr('Resolving requested APIs...');
+        }
+        const servicePrincipals = await odata.getAllItems(`https://graph.microsoft.com/v1.0/myorganization/servicePrincipals?$select=appId,appRoles,id,oauth2PermissionScopes,servicePrincipalNames`);
+        let resolvedApis = [];
+        if (options.apisDelegated || options.apisApplication) {
+            resolvedApis = await getRequiredResourceAccessForApis({
+                servicePrincipals,
+                apis: options.apisDelegated,
+                scopeType: 'Scope',
+                logger,
+                debug
+            });
+            if (verbose) {
+                await logger.logToStderr(`Resolved delegated permissions: ${JSON.stringify(resolvedApis, null, 2)}`);
+            }
+            const resolvedApplicationApis = await getRequiredResourceAccessForApis({
+                servicePrincipals,
+                apis: options.apisApplication,
+                scopeType: 'Role',
+                logger,
+                debug
+            });
+            if (verbose) {
+                await 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 = 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;
+                        updateAppPermissions({
+                            spId: app.id,
+                            resourceAccessPermission,
+                            oAuth2PermissionValue: oAuthValue
+                        });
+                    }));
+                }
+            });
+        }
+        if (verbose) {
+            await logger.logToStderr(`Merged delegated and application permissions: ${JSON.stringify(resolvedApis, null, 2)}`);
+            await logger.logToStderr(`App role assignments: ${JSON.stringify(entraApp.appPermissions.flatMap(permission => permission.resourceAccess.filter(access => access.type === "Role")), null, 2)}`);
+            await logger.logToStderr(`OAuth2 permissions: ${JSON.stringify(entraApp.appPermissions.flatMap(permission => permission.scope), null, 2)}`);
+        }
+        return resolvedApis;
+    }
+};
+//# sourceMappingURL=entraApp.js.map

package/dist/utils/formatting.js

@@ -39,6 +39,22 @@ export const formatting = {
     parseJsonWithBom(s) {
         return JSON.parse(s.replace(/^\uFEFF/, ''));
     },
+    /**
+     * Tries to parse a string as JSON. If it fails, returns the original string.
+     * @param value JSON string to parse.
+     * @returns JSON object or the original string if parsing fails.
+     */
+    tryParseJson(value) {
+        try {
+            if (typeof value !== 'string') {
+                return value;
+            }
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    },
     filterObject(obj, propertiesToInclude) {
         const objKeys = Object.keys(obj);
         return propertiesToInclude