@pnp/cli-microsoft365 9.0.0-beta.33615bd → 9.0.0-beta.59b026e

package/dist/m365/entra/commands/m365group/m365group-user-set.js

@@ -3,14 +3,15 @@ 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 _EntraM365GroupUserSetCommand_instances, _EntraM365GroupUserSetCommand_initTelemetry, _EntraM365GroupUserSetCommand_initOptions, _EntraM365GroupUserSetCommand_initValidators, _EntraM365GroupUserSetCommand_initOptionSets;
+var _EntraM365GroupUserSetCommand_instances, _EntraM365GroupUserSetCommand_initTelemetry, _EntraM365GroupUserSetCommand_initOptions, _EntraM365GroupUserSetCommand_initValidators, _EntraM365GroupUserSetCommand_initOptionSets, _EntraM365GroupUserSetCommand_initTypes;
 import request from '../../../../request.js';
-import { odata } from '../../../../utils/odata.js';
 import { validation } from '../../../../utils/validation.js';
+import { formatting } from '../../../../utils/formatting.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import teamsCommands from '../../../teams/commands.js';
 import commands from '../../commands.js';
 import { entraGroup } from '../../../../utils/entraGroup.js';
+import { entraUser } from '../../../../utils/entraUser.js';
 import aadCommands from '../../aadCommands.js';
 class EntraM365GroupUserSetCommand extends GraphCommand {
     get name() {
@@ -25,135 +26,209 @@ class EntraM365GroupUserSetCommand extends GraphCommand {
     constructor() {
         super();
         _EntraM365GroupUserSetCommand_instances.add(this);
+        this.allowedRoles = ['owner', 'member'];
         __classPrivateFieldGet(this, _EntraM365GroupUserSetCommand_instances, "m", _EntraM365GroupUserSetCommand_initTelemetry).call(this);
         __classPrivateFieldGet(this, _EntraM365GroupUserSetCommand_instances, "m", _EntraM365GroupUserSetCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _EntraM365GroupUserSetCommand_instances, "m", _EntraM365GroupUserSetCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _EntraM365GroupUserSetCommand_instances, "m", _EntraM365GroupUserSetCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _EntraM365GroupUserSetCommand_instances, "m", _EntraM365GroupUserSetCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
         await this.showDeprecationWarning(logger, aadCommands.M365GROUP_USER_SET, commands.M365GROUP_USER_SET);
+        if (args.options.userName) {
+            await this.warn(logger, `Option 'userName' is deprecated. Please use 'ids' or 'userNames' instead.`);
+        }
         try {
-            const groupId = (typeof args.options.groupId !== 'undefined') ? args.options.groupId : args.options.teamId;
+            const userNames = args.options.userNames || args.options.userName;
+            const groupId = await this.getGroupId(logger, args);
             const isUnifiedGroup = await entraGroup.isUnifiedGroup(groupId);
             if (!isUnifiedGroup) {
                 throw Error(`Specified group with id '${groupId}' is not a Microsoft 365 group.`);
             }
-            let users = await this.getOwners(groupId, logger);
-            const membersAndGuests = await this.getMembersAndGuests(groupId, logger);
-            users = users.concat(membersAndGuests);
-            // Filter out duplicate added values for owners (as they are returned as members as well)
-            users = users.filter((groupUser, index, self) => index === self.findIndex((t) => (t.id === groupUser.id && t.displayName === groupUser.displayName)));
-            if (this.debug) {
-                await logger.logToStderr((typeof args.options.groupId !== 'undefined') ? 'Group owners and members:' : 'Team owners and members:');
-                await logger.logToStderr(users);
-                await logger.logToStderr('');
-            }
-            if (users.filter(i => args.options.userName.toUpperCase() === i.userPrincipalName.toUpperCase()).length <= 0) {
-                const userNotInGroup = (typeof args.options.groupId !== 'undefined') ?
-                    'The specified user does not belong to the given Microsoft 365 Group. Please use the \'m365group user add\' command to add new users.' :
-                    'The specified user does not belong to the given Microsoft Teams team. Please use the \'graph teams user add\' command to add new users.';
-                throw new Error(userNotInGroup);
-            }
-            if (args.options.role === "Owner") {
-                const foundMember = users.find(e => args.options.userName.toUpperCase() === e.userPrincipalName.toUpperCase() && e.userType === 'Member');
-                if (foundMember !== undefined) {
-                    const endpoint = `${this.resource}/v1.0/groups/${groupId}/owners/$ref`;
-                    const requestOptions = {
-                        url: endpoint,
-                        headers: {
-                            'accept': 'application/json;odata.metadata=none'
-                        },
-                        responseType: 'json',
-                        data: { "@odata.id": "https://graph.microsoft.com/v1.0/directoryObjects/" + foundMember.id }
-                    };
-                    await request.post(requestOptions);
-                }
-                else {
-                    const userAlreadyOwner = (typeof args.options.groupId !== 'undefined') ?
-                        'The specified user is already an owner in the specified Microsoft 365 group, and thus cannot be promoted.' :
-                        'The specified user is already an owner in the specified Microsoft Teams team, and thus cannot be promoted.';
-                    throw new Error(userAlreadyOwner);
-                }
-            }
-            else {
-                const foundOwner = users.find(e => args.options.userName.toUpperCase() === e.userPrincipalName.toUpperCase() && e.userType === 'Owner');
-                if (foundOwner !== undefined) {
-                    const endpoint = `${this.resource}/v1.0/groups/${groupId}/owners/${foundOwner.id}/$ref`;
-                    const requestOptions = {
-                        url: endpoint,
-                        headers: {
-                            'accept': 'application/json;odata.metadata=none'
-                        }
-                    };
-                    await request.delete(requestOptions);
-                }
-                else {
-                    const userAlreadyMember = (typeof args.options.groupId !== 'undefined') ?
-                        'The specified user is already a member in the specified Microsoft 365 group, and thus cannot be demoted.' :
-                        'The specified user is already a member in the specified Microsoft Teams team, and thus cannot be demoted.';
-                    throw new Error(userAlreadyMember);
-                }
-            }
+            const userIds = await this.getUserIds(logger, args.options.ids, userNames);
+            // we can't simply switch the role
+            // first add users to the new role
+            await this.addUsers(groupId, userIds, args.options.role);
+            // remove users from the old role
+            await this.removeUsersFromRole(logger, groupId, userIds, args.options.role);
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);
         }
     }
-    async getOwners(groupId, logger) {
+    async getGroupId(logger, args) {
+        if (args.options.groupId) {
+            return args.options.groupId;
+        }
+        if (args.options.teamId) {
+            return args.options.teamId;
+        }
+        const name = args.options.groupName || args.options.teamName;
         if (this.verbose) {
-            await logger.logToStderr(`Retrieving owners of the group with id ${groupId}`);
-        }
-        const endpoint = `${this.resource}/v1.0/groups/${groupId}/owners?$select=id,displayName,userPrincipalName,userType`;
-        const users = await odata.getAllItems(endpoint);
-        // Currently there is a bug in the Microsoft Graph that returns Owners as
-        // userType 'member'. We therefore update all returned user as owner
-        users.forEach(user => {
-            user.userType = 'Owner';
-        });
-        return users;
+            await logger.logToStderr('Retrieving Group ID by display name...');
+        }
+        return entraGroup.getGroupIdByDisplayName(name);
+    }
+    async getUserIds(logger, userIds, userNames) {
+        if (userIds) {
+            return formatting.splitAndTrim(userIds);
+        }
+        if (this.verbose) {
+            await logger.logToStderr('Retrieving user ID(s) by username(s)...');
+        }
+        return entraUser.getUserIdsByUpns(formatting.splitAndTrim(userNames));
     }
-    async getMembersAndGuests(groupId, logger) {
+    async removeUsersFromRole(logger, groupId, userIds, role) {
+        const userIdsToRemove = [];
+        const currentRole = (role.toLowerCase() === 'member') ? 'owners' : 'members';
         if (this.verbose) {
-            await logger.logToStderr(`Retrieving members of the group with id ${groupId}`);
+            await logger.logToStderr(`Removing users from the old role '${currentRole}'.`);
+        }
+        for (let i = 0; i < userIds.length; i += 20) {
+            const userIdsBatch = userIds.slice(i, i + 20);
+            const requestOptions = this.getRequestOptions();
+            userIdsBatch.map(userId => {
+                requestOptions.data.requests.push({
+                    id: userId,
+                    method: 'GET',
+                    url: `/groups/${groupId}/${currentRole}/$count?$filter=id eq '${userId}'`,
+                    headers: {
+                        'ConsistencyLevel': 'eventual'
+                    }
+                });
+            });
+            // send batch request
+            const res = await request.post(requestOptions);
+            for (const response of res.responses) {
+                if (response.status === 200) {
+                    if (response.body === 1) {
+                        // user can be removed from current role
+                        userIdsToRemove.push(response.id);
+                    }
+                }
+                else {
+                    throw response.body;
+                }
+            }
+        }
+        for (let i = 0; i < userIdsToRemove.length; i += 20) {
+            const userIdsBatch = userIds.slice(i, i + 20);
+            const requestOptions = this.getRequestOptions();
+            userIdsBatch.map(userId => {
+                requestOptions.data.requests.push({
+                    id: userId,
+                    method: 'DELETE',
+                    url: `/groups/${groupId}/${currentRole}/${userId}/$ref`
+                });
+            });
+            const res = await request.post(requestOptions);
+            for (const response of res.responses) {
+                if (response.status !== 204) {
+                    throw response.body;
+                }
+            }
+        }
+    }
+    async addUsers(groupId, userIds, role) {
+        for (let i = 0; i < userIds.length; i += 400) {
+            const userIdsBatch = userIds.slice(i, i + 400);
+            const requestOptions = this.getRequestOptions();
+            for (let j = 0; j < userIdsBatch.length; j += 20) {
+                const userIdsChunk = userIdsBatch.slice(j, j + 20);
+                requestOptions.data.requests.push({
+                    id: j + 1,
+                    method: 'PATCH',
+                    url: `/groups/${groupId}`,
+                    headers: {
+                        'content-type': 'application/json;odata.metadata=none'
+                    },
+                    body: {
+                        [`${role.toLowerCase() === 'member' ? 'members' : 'owners'}@odata.bind`]: userIdsChunk.map(u => `${this.resource}/v1.0/directoryObjects/${u}`)
+                    }
+                });
+            }
+            const res = await request.post(requestOptions);
+            for (const response of res.responses) {
+                if (response.status !== 204) {
+                    throw response.body;
+                }
+            }
         }
-        const endpoint = `${this.resource}/v1.0/groups/${groupId}/members?$select=id,displayName,userPrincipalName,userType`;
-        return await odata.getAllItems(endpoint);
+    }
+    getRequestOptions() {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/$batch`,
+            headers: {
+                'content-type': 'application/json;odata.metadata=none'
+            },
+            responseType: 'json',
+            data: {
+                requests: []
+            }
+        };
+        return requestOptions;
     }
 }
 _EntraM365GroupUserSetCommand_instances = new WeakSet(), _EntraM365GroupUserSetCommand_initTelemetry = function _EntraM365GroupUserSetCommand_initTelemetry() {
     this.telemetry.push((args) => {
         Object.assign(this.telemetryProperties, {
             teamId: typeof args.options.teamId !== 'undefined',
+            teamName: typeof args.options.teamName !== 'undefined',
             groupId: typeof args.options.groupId !== 'undefined',
-            role: args.options.role
+            groupName: typeof args.options.groupName !== 'undefined',
+            ids: typeof args.options.ids !== 'undefined',
+            userNames: typeof args.options.userNames !== 'undefined'
         });
     });
 }, _EntraM365GroupUserSetCommand_initOptions = function _EntraM365GroupUserSetCommand_initOptions() {
     this.options.unshift({
-        option: "-i, --groupId [groupId]"
+        option: '-n, --userName [userName]'
+    }, {
+        option: '--ids [ids]'
+    }, {
+        option: '--userNames [userNames]'
+    }, {
+        option: '-i, --groupId [groupId]'
     }, {
-        option: "--teamId [teamId]"
+        option: '--groupName [groupName]'
     }, {
-        option: '-n, --userName <userName>'
+        option: '--teamId [teamId]'
+    }, {
+        option: '--teamName [teamName]'
     }, {
         option: '-r, --role <role>',
-        autocomplete: ['Owner', 'Member']
+        autocomplete: this.allowedRoles
     });
 }, _EntraM365GroupUserSetCommand_initValidators = function _EntraM365GroupUserSetCommand_initValidators() {
     this.validators.push(async (args) => {
         if (args.options.teamId && !validation.isValidGuid(args.options.teamId)) {
-            return `${args.options.teamId} is not a valid GUID`;
+            return `'${args.options.teamId}' is not a valid GUID for option 'teamId'.`;
         }
         if (args.options.groupId && !validation.isValidGuid(args.options.groupId)) {
-            return `${args.options.groupId} is not a valid GUID`;
+            return `'${args.options.groupId}' is not a valid GUID for option 'groupId'.`;
+        }
+        if (args.options.ids) {
+            const isValidGUIDArrayResult = validation.isValidGuidArray(args.options.ids);
+            if (isValidGUIDArrayResult !== true) {
+                return `The following GUIDs are invalid for the option 'ids': ${isValidGUIDArrayResult}.`;
+            }
+        }
+        if (args.options.userNames) {
+            const isValidUPNArrayResult = validation.isValidUserPrincipalNameArray(args.options.userNames);
+            if (isValidUPNArrayResult !== true) {
+                return `The following user principal names are invalid for the option 'userNames': ${isValidUPNArrayResult}.`;
+            }
         }
-        if (['Owner', 'Member'].indexOf(args.options.role) === -1) {
-            return `${args.options.role} is not a valid role value. Allowed values Owner|Member`;
+        if (args.options.role && !this.allowedRoles.some(role => role.toLowerCase() === args.options.role.toLowerCase())) {
+            return `'${args.options.role}' is not a valid role. Allowed values are: ${this.allowedRoles.join(',')}`;
         }
         return true;
     });
 }, _EntraM365GroupUserSetCommand_initOptionSets = function _EntraM365GroupUserSetCommand_initOptionSets() {
-    this.optionSets.push({ options: ['groupId', 'teamId'] });
+    this.optionSets.push({ options: ['groupId', 'groupName', 'teamId', 'teamName'] });
+    this.optionSets.push({ options: ['userName', 'ids', 'userNames'] });
+}, _EntraM365GroupUserSetCommand_initTypes = function _EntraM365GroupUserSetCommand_initTypes() {
+    this.types.string.push('userName', 'ids', 'userNames', 'groupId', 'groupName', 'teamId', 'teamName', 'role');
 };
 export default new EntraM365GroupUserSetCommand();
 //# sourceMappingURL=m365group-user-set.js.map

package/dist/m365/flow/commands/flow-get.js

@@ -29,7 +29,7 @@ class FlowGetCommand extends PowerAutomateCommand {
             await logger.logToStderr(`Retrieving information about Microsoft Flow ${args.options.name}...`);
         }
         const requestOptions = {
-            url: `${this.resource}/providers/Microsoft.ProcessSimple/${args.options.asAdmin ? 'scopes/admin/' : ''}environments/${formatting.encodeQueryParameter(args.options.environmentName)}/flows/${formatting.encodeQueryParameter(args.options.name)}?api-version=2016-11-01`,
+            url: `${this.resource}/providers/Microsoft.ProcessSimple/${args.options.asAdmin ? 'scopes/admin/' : ''}environments/${formatting.encodeQueryParameter(args.options.environmentName)}/flows/${formatting.encodeQueryParameter(args.options.name)}?api-version=2016-11-01&$expand=swagger,properties.connectionreferences.apidefinition,properties.definitionsummary.operations.apioperation,operationDefinition,plan,properties.throttleData,properties.estimatedsuspensiondata,properties.licenseData`,
             headers: {
                 accept: 'application/json'
             },

package/dist/m365/spfx/commands/project/DeployWorkflow.js

@@ -46,7 +46,7 @@ export const workflow = {
                     with: {
                         "APP_FILE_PATH": "sharepoint/solution/{{ solutionName }}.sppkg",
                         "SKIP_FEATURE_DEPLOYMENT": false,
-                        "OVERWRITE": false
+                        "OVERWRITE": true
                     }
                 }
             ]

package/dist/m365/spfx/commands/project/project-github-workflow-add.js

@@ -33,9 +33,6 @@ class SpfxProjectGithubWorkflowAddCommand extends BaseProjectCommand {
         if (this.projectRootPath === null) {
             throw new CommandError(`Couldn't find project root folder`, _a.ERROR_NO_PROJECT_ROOT_FOLDER);
         }
-        if (!args.options.overwrite) {
-            await this.warn(logger, `We recommend always using the --overwrite option and it will become the default behavior in next major release. Overwriting your sppkg file on every deployment is required to make continuous delivery of the latest version of your app which is the aim of the continuous delivery pipeline.`);
-        }
         const solutionPackageJsonFile = path.join(this.projectRootPath, 'package.json');
         const packageJson = fs.readFileSync(solutionPackageJsonFile, 'utf-8');
         const solutionName = JSON.parse(packageJson).name;
@@ -81,9 +78,6 @@ class SpfxProjectGithubWorkflowAddCommand extends BaseProjectCommand {
         if (options.skipFeatureDeployment) {
             this.getDeployAction(workflow).with.SKIP_FEATURE_DEPLOYMENT = true;
         }
-        if (options.overwrite) {
-            this.getDeployAction(workflow).with.OVERWRITE = true;
-        }
         if (options.loginMethod === 'user') {
             const loginAction = this.getLoginAction(workflow);
             loginAction.with = {
@@ -125,8 +119,7 @@ _a = SpfxProjectGithubWorkflowAddCommand, _SpfxProjectGithubWorkflowAddCommand_i
             manuallyTrigger: !!args.options.manuallyTrigger,
             loginMethod: typeof args.options.loginMethod !== 'undefined',
             scope: typeof args.options.scope !== 'undefined',
-            skipFeatureDeployment: !!args.options.skipFeatureDeployment,
-            overwrite: !!args.options.overwrite
+            skipFeatureDeployment: !!args.options.skipFeatureDeployment
         });
     });
 }, _SpfxProjectGithubWorkflowAddCommand_initOptions = function _SpfxProjectGithubWorkflowAddCommand_initOptions() {
@@ -146,8 +139,6 @@ _a = SpfxProjectGithubWorkflowAddCommand, _SpfxProjectGithubWorkflowAddCommand_i
         option: '-u, --siteUrl [siteUrl]'
     }, {
         option: '--skipFeatureDeployment'
-    }, {
-        option: '--overwrite'
     });
 }, _SpfxProjectGithubWorkflowAddCommand_initValidators = function _SpfxProjectGithubWorkflowAddCommand_initValidators() {
     this.validators.push(async (args) => {

package/dist/m365/spo/commands/file/file-copy.js

@@ -5,6 +5,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _SpoFileCopyCommand_instances, _SpoFileCopyCommand_initTelemetry, _SpoFileCopyCommand_initOptions, _SpoFileCopyCommand_initValidators, _SpoFileCopyCommand_initOptionSets, _SpoFileCopyCommand_initTypes;
 import request from '../../../../request.js';
+import { CreateCopyJobsNameConflictBehavior, spo } from '../../../../utils/spo.js';
 import { urlUtil } from '../../../../utils/urlUtil.js';
 import { validation } from '../../../../utils/validation.js';
 import SpoCommand from '../../../base/SpoCommand.js';
@@ -30,39 +31,43 @@ class SpoFileCopyCommand extends SpoCommand {
         try {
             const sourceServerRelativePath = await this.getSourcePath(logger, args.options);
             const sourcePath = this.getAbsoluteUrl(args.options.webUrl, sourceServerRelativePath);
-            let destinationPath = this.getAbsoluteUrl(args.options.webUrl, args.options.targetUrl) + '/';
-            if (args.options.newName) {
-                destinationPath += args.options.newName;
+            const destinationPath = this.getAbsoluteUrl(args.options.webUrl, args.options.targetUrl);
+            if (this.verbose) {
+                await logger.logToStderr(`Copying file '${sourceServerRelativePath}' to '${args.options.targetUrl}'...`);
+            }
+            let newName = args.options.newName;
+            // Add original file extension if not provided
+            if (newName && !newName.includes('.')) {
+                newName += sourceServerRelativePath.substring(sourceServerRelativePath.lastIndexOf('.'));
             }
-            else {
-                // Keep the original file name
-                destinationPath += sourcePath.substring(sourcePath.lastIndexOf('/') + 1);
+            const copyJobResponse = await spo.createCopyJob(args.options.webUrl, sourcePath, destinationPath, {
+                nameConflictBehavior: this.getNameConflictBehaviorValue(args.options.nameConflictBehavior),
+                bypassSharedLock: !!args.options.bypassSharedLock,
+                ignoreVersionHistory: !!args.options.ignoreVersionHistory,
+                newName: newName
+            });
+            if (args.options.skipWait) {
+                return;
             }
             if (this.verbose) {
-                await logger.logToStderr(`Copying file '${sourcePath}' to '${destinationPath}'...`);
+                await logger.logToStderr('Waiting for the copy job to complete...');
             }
+            const copyJobResult = await spo.getCopyJobResult(args.options.webUrl, copyJobResponse);
+            if (this.verbose) {
+                await logger.logToStderr('Getting information about the destination file...');
+            }
+            // Get destination file data
+            const siteRelativeDestinationFolder = '/' + copyJobResult.TargetObjectSiteRelativeUrl.substring(0, copyJobResult.TargetObjectSiteRelativeUrl.lastIndexOf('/'));
+            const absoluteWebUrl = destinationPath.substring(0, destinationPath.toLowerCase().lastIndexOf(siteRelativeDestinationFolder.toLowerCase()));
             const requestOptions = {
-                url: `${args.options.webUrl}/_api/SP.MoveCopyUtil.CopyFileByPath`,
+                url: `${absoluteWebUrl}/_api/Web/GetFileById('${copyJobResult.TargetObjectUniqueId}')`,
                 headers: {
                     accept: 'application/json;odata=nometadata'
                 },
-                responseType: 'json',
-                data: {
-                    srcPath: {
-                        DecodedUrl: sourcePath
-                    },
-                    destPath: {
-                        DecodedUrl: destinationPath
-                    },
-                    overwrite: args.options.nameConflictBehavior === 'replace',
-                    options: {
-                        KeepBoth: args.options.nameConflictBehavior === 'rename',
-                        ResetAuthorAndCreatedOnCopy: !!args.options.resetAuthorAndCreated,
-                        ShouldBypassSharedLocks: !!args.options.bypassSharedLock
-                    }
-                }
+                responseType: 'json'
             };
-            await request.post(requestOptions);
+            const destinationFile = await request.get(requestOptions);
+            await logger.log(destinationFile);
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);
@@ -76,17 +81,30 @@ class SpoFileCopyCommand extends SpoCommand {
             await logger.logToStderr(`Retrieving server-relative path for file with ID '${options.sourceId}'...`);
         }
         const requestOptions = {
-            url: `${options.webUrl}/_api/Web/GetFileById('${options.sourceId}')?$select=ServerRelativePath`,
+            url: `${options.webUrl}/_api/Web/GetFileById('${options.sourceId}')/ServerRelativePath`,
             headers: {
                 accept: 'application/json;odata=nometadata'
             },
             responseType: 'json'
         };
         const file = await request.get(requestOptions);
-        return file.ServerRelativePath.DecodedUrl;
+        return file.DecodedUrl;
+    }
+    getNameConflictBehaviorValue(nameConflictBehavior) {
+        switch (nameConflictBehavior?.toLowerCase()) {
+            case 'fail':
+                return CreateCopyJobsNameConflictBehavior.Fail;
+            case 'replace':
+                return CreateCopyJobsNameConflictBehavior.Replace;
+            case 'rename':
+                return CreateCopyJobsNameConflictBehavior.Rename;
+            default:
+                return CreateCopyJobsNameConflictBehavior.Fail;
+        }
     }
     getAbsoluteUrl(webUrl, url) {
-        return url.startsWith('https://') ? url : urlUtil.getAbsoluteUrl(webUrl, url);
+        const result = url.startsWith('https://') ? url : urlUtil.getAbsoluteUrl(webUrl, url);
+        return urlUtil.removeTrailingSlashes(result);
     }
 }
 _SpoFileCopyCommand_instances = new WeakSet(), _SpoFileCopyCommand_initTelemetry = function _SpoFileCopyCommand_initTelemetry() {
@@ -95,9 +113,10 @@ _SpoFileCopyCommand_instances = new WeakSet(), _SpoFileCopyCommand_initTelemetry
             sourceUrl: typeof args.options.sourceUrl !== 'undefined',
             sourceId: typeof args.options.sourceId !== 'undefined',
             newName: typeof args.options.newName !== 'undefined',
-            nameConflictBehavior: args.options.nameConflictBehavior || false,
-            resetAuthorAndCreated: !!args.options.resetAuthorAndCreated,
-            bypassSharedLock: !!args.options.bypassSharedLock
+            nameConflictBehavior: typeof args.options.nameConflictBehavior !== 'undefined',
+            ignoreVersionHistory: !!args.options.ignoreVersionHistory,
+            bypassSharedLock: !!args.options.bypassSharedLock,
+            skipWait: !!args.options.skipWait
         });
     });
 }, _SpoFileCopyCommand_initOptions = function _SpoFileCopyCommand_initOptions() {
@@ -114,10 +133,12 @@ _SpoFileCopyCommand_instances = new WeakSet(), _SpoFileCopyCommand_initTelemetry
     }, {
         option: '--nameConflictBehavior [nameConflictBehavior]',
         autocomplete: this.nameConflictBehaviorOptions
-    }, {
-        option: '--resetAuthorAndCreated'
     }, {
         option: '--bypassSharedLock'
+    }, {
+        option: '--ignoreVersionHistory'
+    }, {
+        option: '--skipWait'
     });
 }, _SpoFileCopyCommand_initValidators = function _SpoFileCopyCommand_initValidators() {
     this.validators.push(async (args) => {
@@ -128,7 +149,7 @@ _SpoFileCopyCommand_instances = new WeakSet(), _SpoFileCopyCommand_initTelemetry
         if (args.options.sourceId && !validation.isValidGuid(args.options.sourceId)) {
             return `${args.options.sourceId} is not a valid GUID for sourceId.`;
         }
-        if (args.options.nameConflictBehavior && this.nameConflictBehaviorOptions.indexOf(args.options.nameConflictBehavior) === -1) {
+        if (args.options.nameConflictBehavior && !this.nameConflictBehaviorOptions.includes(args.options.nameConflictBehavior.toLowerCase())) {
             return `${args.options.nameConflictBehavior} is not a valid nameConflictBehavior value. Allowed values: ${this.nameConflictBehaviorOptions.join(', ')}.`;
         }
         return true;
@@ -137,7 +158,7 @@ _SpoFileCopyCommand_instances = new WeakSet(), _SpoFileCopyCommand_initTelemetry
     this.optionSets.push({ options: ['sourceUrl', 'sourceId'] });
 }, _SpoFileCopyCommand_initTypes = function _SpoFileCopyCommand_initTypes() {
     this.types.string.push('webUrl', 'sourceUrl', 'sourceId', 'targetUrl', 'newName', 'nameConflictBehavior');
-    this.types.boolean.push('resetAuthorAndCreated', 'bypassSharedLock');
+    this.types.boolean.push('bypassSharedLock', 'ignoreVersionHistory', 'skipWait');
 };
 export default new SpoFileCopyCommand();
 //# sourceMappingURL=file-copy.js.map

package/dist/m365/spo/commands/folder/folder-set.js

@@ -18,9 +18,6 @@ class SpoFolderSetCommand extends SpoCommand {
     get description() {
         return 'Updates a folder';
     }
-    alias() {
-        return [commands.FOLDER_RENAME];
-    }
     constructor() {
         super();
         _SpoFolderSetCommand_instances.add(this);
@@ -34,7 +31,6 @@ class SpoFolderSetCommand extends SpoCommand {
     }
     async commandAction(logger, args) {
         try {
-            await this.showDeprecationWarning(logger, this.alias()[0], this.name);
             if (this.verbose) {
                 await logger.logToStderr(`Updating folder '${args.options.name}'...`);
             }

package/dist/m365/spo/commands/folder/folder-sharinglink-get.js

@@ -0,0 +1,86 @@
+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 _SpoFolderSharingLinkGetCommand_instances, _SpoFolderSharingLinkGetCommand_initTelemetry, _SpoFolderSharingLinkGetCommand_initOptions, _SpoFolderSharingLinkGetCommand_initOptionSets, _SpoFolderSharingLinkGetCommand_initValidators, _SpoFolderSharingLinkGetCommand_initTypes;
+import request from '../../../../request.js';
+import { spo } from '../../../../utils/spo.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+import { drive as driveItem } from '../../../../utils/drive.js';
+class SpoFolderSharingLinkGetCommand extends SpoCommand {
+    get name() {
+        return commands.FOLDER_SHARINGLINK_GET;
+    }
+    get description() {
+        return 'Gets details about a specific sharing link on a folder';
+    }
+    constructor() {
+        super();
+        _SpoFolderSharingLinkGetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkGetCommand_instances, "m", _SpoFolderSharingLinkGetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkGetCommand_instances, "m", _SpoFolderSharingLinkGetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkGetCommand_instances, "m", _SpoFolderSharingLinkGetCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkGetCommand_instances, "m", _SpoFolderSharingLinkGetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoFolderSharingLinkGetCommand_instances, "m", _SpoFolderSharingLinkGetCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        if (this.verbose) {
+            await logger.logToStderr(`Retrieving sharing link on folder ${args.options.folderId || args.options.folderUrl}...`);
+        }
+        try {
+            const relFolderUrl = await spo.getFolderServerRelativeUrl(args.options.webUrl, args.options.folderUrl, args.options.folderId);
+            const absoluteFolderUrl = urlUtil.getAbsoluteUrl(args.options.webUrl, relFolderUrl);
+            const folderUrl = new URL(absoluteFolderUrl);
+            const siteId = await spo.getSiteId(args.options.webUrl);
+            const drive = await driveItem.getDriveByUrl(siteId, folderUrl);
+            const itemId = await driveItem.getDriveItemId(drive, folderUrl);
+            const requestUrl = `https://graph.microsoft.com/v1.0/drives/${drive.id}/items/${itemId}/permissions/${args.options.id}`;
+            const requestOptions = {
+                url: requestUrl,
+                headers: {
+                    'accept': 'application/json;odata.metadata=none'
+                },
+                responseType: 'json'
+            };
+            const permission = await request.get(requestOptions);
+            await logger.log(permission);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+_SpoFolderSharingLinkGetCommand_instances = new WeakSet(), _SpoFolderSharingLinkGetCommand_initTelemetry = function _SpoFolderSharingLinkGetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            folderUrl: typeof args.options.folderUrl !== 'undefined',
+            folderId: typeof args.options.folderId !== 'undefined'
+        });
+    });
+}, _SpoFolderSharingLinkGetCommand_initOptions = function _SpoFolderSharingLinkGetCommand_initOptions() {
+    this.options.unshift({ option: '-u, --webUrl <webUrl>' }, { option: '--folderUrl [folderUrl]' }, { option: '--folderId [folderId]' }, { option: '-i, --id <id>' });
+}, _SpoFolderSharingLinkGetCommand_initOptionSets = function _SpoFolderSharingLinkGetCommand_initOptionSets() {
+    this.optionSets.push({ options: ['folderUrl', 'folderId'] });
+}, _SpoFolderSharingLinkGetCommand_initValidators = function _SpoFolderSharingLinkGetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.webUrl);
+        if (isValidSharePointUrl !== true) {
+            return isValidSharePointUrl;
+        }
+        if (args.options.folderId && !validation.isValidGuid(args.options.folderId)) {
+            return `${args.options.folderId} is not a valid GUID for option 'folderId'.`;
+        }
+        if (!validation.isValidGuid(args.options.id)) {
+            return `${args.options.id} is not a valid GUID for option 'id'.`;
+        }
+        return true;
+    });
+}, _SpoFolderSharingLinkGetCommand_initTypes = function _SpoFolderSharingLinkGetCommand_initTypes() {
+    this.types.string.push('webUrl', 'folderUrl', 'folderId', 'id');
+};
+export default new SpoFolderSharingLinkGetCommand();
+//# sourceMappingURL=folder-sharinglink-get.js.map