@pnp/cli-microsoft365 7.8.0-beta.5ca5055 → 7.8.0-beta.a83837a

package/dist/m365/planner/commands/task/task-list.js

@@ -4,7 +4,6 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _PlannerTaskListCommand_instances, _PlannerTaskListCommand_initTelemetry, _PlannerTaskListCommand_initOptions, _PlannerTaskListCommand_initValidators, _PlannerTaskListCommand_initOptionSets, _PlannerTaskListCommand_initTypes;
-import request from '../../../../request.js';
 import { entraGroup } from '../../../../utils/entraGroup.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { odata } from '../../../../utils/odata.js';
@@ -37,37 +36,27 @@ class PlannerTaskListCommand extends GraphCommand {
         const planTitle = args.options.planTitle;
         let planId = args.options.planId;
         let taskItems = [];
-        if (bucketId || bucketName) {
-            try {
+        try {
+            if (bucketId || bucketName) {
                 bucketId = await this.getBucketId(args);
                 taskItems = await odata.getAllItems(`${this.resource}/v1.0/planner/buckets/${bucketId}/tasks`);
                 const betaTasks = await odata.getAllItems(`${this.resource}/beta/planner/buckets/${bucketId}/tasks`);
                 await logger.log(this.mergeTaskPriority(taskItems, betaTasks));
             }
-            catch (err) {
-                this.handleRejectedODataJsonPromise(err);
-            }
-        }
-        else if (planId || planTitle) {
-            try {
+            else if (planId || planTitle) {
                 planId = await this.getPlanId(args);
                 taskItems = await odata.getAllItems(`${this.resource}/v1.0/planner/plans/${planId}/tasks`);
                 const betaTasks = await odata.getAllItems(`${this.resource}/beta/planner/plans/${planId}/tasks`);
                 await logger.log(this.mergeTaskPriority(taskItems, betaTasks));
             }
-            catch (err) {
-                this.handleRejectedODataJsonPromise(err);
-            }
-        }
-        else {
-            try {
+            else {
                 taskItems = await odata.getAllItems(`${this.resource}/v1.0/me/planner/tasks`);
                 const betaTasks = await odata.getAllItems(`${this.resource}/beta/me/planner/tasks`);
                 await logger.log(this.mergeTaskPriority(taskItems, betaTasks));
             }
-            catch (err) {
-                this.handleRejectedODataJsonPromise(err);
-            }
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
         }
     }
     async getBucketId(args) {
@@ -75,40 +64,25 @@ class PlannerTaskListCommand extends GraphCommand {
             return formatting.encodeQueryParameter(args.options.bucketId);
         }
         const planId = await this.getPlanId(args);
-        const requestOptions = {
-            url: `${this.resource}/v1.0/planner/plans/${planId}/buckets`,
-            headers: {
-                accept: 'application/json;odata.metadata=none'
-            },
-            responseType: 'json'
-        };
-        const response = await request.get(requestOptions);
-        const bucket = response.value.find(val => val.name === args.options.bucketName);
-        if (!bucket) {
-            throw `The specified bucket does not exist`;
-        }
-        return bucket.id;
+        return planner.getBucketIdByTitle(args.options.bucketName, planId);
     }
     async getPlanId(args) {
         if (args.options.planId) {
             return formatting.encodeQueryParameter(args.options.planId);
         }
         if (args.options.rosterId) {
-            const plan = await planner.getPlanByRosterId(args.options.rosterId);
-            return plan.id;
+            return planner.getPlanIdByRosterId(args.options.rosterId);
         }
         else {
             const groupId = await this.getGroupId(args);
-            const plan = await planner.getPlanByTitle(args.options.planTitle, groupId);
-            return plan.id;
+            return planner.getPlanIdByTitle(args.options.planTitle, groupId);
         }
     }
     async getGroupId(args) {
         if (args.options.ownerGroupId) {
             return formatting.encodeQueryParameter(args.options.ownerGroupId);
         }
-        const group = await entraGroup.getGroupByDisplayName(args.options.ownerGroupName);
-        return group.id;
+        return entraGroup.getGroupIdByDisplayName(args.options.ownerGroupName);
     }
     mergeTaskPriority(taskItems, betaTaskItems) {
         const findBetaTask = (id) => betaTaskItems.find(task => task.id === id);

package/dist/m365/planner/commands/task/task-reference-remove.js

@@ -94,7 +94,7 @@ _PlannerTaskReferenceRemoveCommand_instances = new WeakSet(), _PlannerTaskRefere
         Object.assign(this.telemetryProperties, {
             url: typeof args.options.url !== 'undefined',
             alias: typeof args.options.alias !== 'undefined',
-            force: (!(!args.options.force)).toString()
+            force: !!args.options.force
         });
     });
 }, _PlannerTaskReferenceRemoveCommand_initOptions = function _PlannerTaskReferenceRemoveCommand_initOptions() {

package/dist/m365/planner/commands/task/task-remove.js

@@ -33,6 +33,9 @@ class PlannerTaskRemoveCommand extends GraphCommand {
         const removeTask = async () => {
             try {
                 const task = await this.getTask(args.options);
+                if (this.verbose) {
+                    await logger.logToStderr(`Removing task '${task.title}' ...`);
+                }
                 const requestOptions = {
                     url: `${this.resource}/v1.0/planner/tasks/${task.id}`,
                     headers: {
@@ -72,15 +75,15 @@ class PlannerTaskRemoveCommand extends GraphCommand {
         const bucketId = await this.getBucketId(options);
         // $filter is not working on the buckets/{bucketId}/tasks endpoint, hence it is not being used.
         const tasks = await odata.getAllItems(`${this.resource}/v1.0/planner/buckets/${bucketId}/tasks?$select=title,id`, 'minimal');
-        const filteredtasks = tasks.filter(b => title.toLocaleLowerCase() === b.title.toLocaleLowerCase());
-        if (filteredtasks.length === 0) {
+        const filteredTasks = tasks.filter(b => title.toLocaleLowerCase() === b.title.toLocaleLowerCase());
+        if (filteredTasks.length === 0) {
             throw `The specified task ${title} does not exist`;
         }
-        if (filteredtasks.length > 1) {
-            const resultAsKeyValuePair = formatting.convertArrayToHashTable('id', filteredtasks);
+        if (filteredTasks.length > 1) {
+            const resultAsKeyValuePair = formatting.convertArrayToHashTable('id', filteredTasks);
             return await cli.handleMultipleResultsFound(`Multiple tasks with title '${title}' found.`, resultAsKeyValuePair);
         }
-        return filteredtasks[0];
+        return filteredTasks[0];
     }
     async getBucketId(options) {
         const { bucketId, bucketName } = options;
@@ -88,24 +91,7 @@ class PlannerTaskRemoveCommand extends GraphCommand {
             return bucketId;
         }
         const planId = await this.getPlanId(options);
-        const requestOptions = {
-            url: `${this.resource}/v1.0/planner/plans/${planId}/buckets?$select=id,name`,
-            headers: {
-                accept: 'application/json;odata.metadata=none'
-            },
-            responseType: 'json'
-        };
-        const buckets = await request.get(requestOptions);
-        const filteredBuckets = buckets.value.filter(b => bucketName.toLocaleLowerCase() === b.name.toLocaleLowerCase());
-        if (filteredBuckets.length === 0) {
-            throw `The specified bucket ${bucketName} does not exist`;
-        }
-        if (filteredBuckets.length > 1) {
-            const resultAsKeyValuePair = formatting.convertArrayToHashTable('id', filteredBuckets);
-            const result = await cli.handleMultipleResultsFound(`Multiple buckets with name '${bucketName}' found.`, resultAsKeyValuePair);
-            return result.id;
-        }
-        return filteredBuckets[0].id;
+        return planner.getBucketIdByTitle(bucketName, planId);
     }
     async getPlanId(options) {
         const { planId, planTitle, rosterId } = options;
@@ -113,13 +99,11 @@ class PlannerTaskRemoveCommand extends GraphCommand {
             return planId;
         }
         if (options.rosterId) {
-            const plan = await planner.getPlanByRosterId(rosterId);
-            return plan.id;
+            return planner.getPlanIdByRosterId(rosterId);
         }
         else {
             const groupId = await this.getGroupId(options);
-            const plan = await planner.getPlanByTitle(planTitle, groupId);
-            return plan.id;
+            return planner.getPlanIdByTitle(planTitle, groupId);
         }
     }
     async getGroupId(options) {
@@ -127,8 +111,7 @@ class PlannerTaskRemoveCommand extends GraphCommand {
         if (ownerGroupId) {
             return ownerGroupId;
         }
-        const group = await entraGroup.getGroupByDisplayName(ownerGroupName);
-        return group.id;
+        return entraGroup.getGroupIdByDisplayName(ownerGroupName);
     }
 }
 _PlannerTaskRemoveCommand_instances = new WeakSet(), _PlannerTaskRemoveCommand_initTelemetry = function _PlannerTaskRemoveCommand_initTelemetry() {

package/dist/m365/planner/commands/task/task-set.js

@@ -154,40 +154,25 @@ class PlannerTaskSetCommand extends GraphCommand {
             return undefined;
         }
         const planId = await this.getPlanId(options);
-        const requestOptions = {
-            url: `${this.resource}/v1.0/planner/plans/${planId}/buckets?$select=id,name`,
-            headers: {
-                accept: 'application/json;odata.metadata=none'
-            },
-            responseType: 'json'
-        };
-        const response = await request.get(requestOptions);
-        const bucket = response.value.find(val => val.name === options.bucketName);
-        if (!bucket) {
-            throw 'The specified bucket does not exist';
-        }
-        return bucket.id;
+        return planner.getBucketIdByTitle(options.bucketName, planId);
     }
     async getPlanId(options) {
         if (options.planId) {
             return options.planId;
         }
         if (options.rosterId) {
-            const plan = await planner.getPlanByRosterId(options.rosterId);
-            return plan.id;
+            return planner.getPlanIdByRosterId(options.rosterId);
         }
         else {
             const groupId = await this.getGroupId(options);
-            const plan = await planner.getPlanByTitle(options.planTitle, groupId);
-            return plan.id;
+            return planner.getPlanIdByTitle(options.planTitle, groupId);
         }
     }
     async getGroupId(options) {
         if (options.ownerGroupId) {
             return options.ownerGroupId;
         }
-        const group = await entraGroup.getGroupByDisplayName(options.ownerGroupName);
-        return group.id;
+        return entraGroup.getGroupIdByDisplayName(options.ownerGroupName);
     }
     mapRequestBody(options, appliedCategories) {
         const requestBody = {};
@@ -266,8 +251,17 @@ _PlannerTaskSetCommand_instances = new WeakSet(), _PlannerTaskSetCommand_initTel
         if (args.options.percentComplete && (args.options.percentComplete < 0 || args.options.percentComplete > 100)) {
             return `percentComplete should be between 0 and 100`;
         }
-        if (args.options.assignedToUserIds && !validation.isValidGuidArray(args.options.assignedToUserIds.split(','))) {
-            return 'assignedToUserIds contains invalid GUID';
+        if (args.options.assignedToUserIds) {
+            const isValidGUIDArrayResult = validation.isValidGuidArray(args.options.assignedToUserIds);
+            if (isValidGUIDArrayResult !== true) {
+                return `The following GUIDs are invalid for the option 'assignedToUserIds': ${isValidGUIDArrayResult}.`;
+            }
+        }
+        if (args.options.assignedToUserNames) {
+            const isValidUPNArrayResult = validation.isValidUserPrincipalNameArray(args.options.assignedToUserNames);
+            if (isValidUPNArrayResult !== true) {
+                return `The following user principal names are invalid for the option 'assignedToUserNames': ${isValidUPNArrayResult}.`;
+            }
         }
         if (args.options.appliedCategories && args.options.appliedCategories.split(',').filter(category => this.allowedAppliedCategories.indexOf(category.toLocaleLowerCase()) < 0).length !== 0) {
             return 'The appliedCategories contains invalid value. Specify either category1, category2, category3, category4, category5 and/or category6 as properties';

package/dist/m365/spo/commands/listitem/listitem-batch-remove.js

@@ -0,0 +1,222 @@
+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 _SpoListItemBatchRemoveCommand_instances, _SpoListItemBatchRemoveCommand_initTelemetry, _SpoListItemBatchRemoveCommand_initOptions, _SpoListItemBatchRemoveCommand_initValidators, _SpoListItemBatchRemoveCommand_initTypes, _SpoListItemBatchRemoveCommand_initOptionSets;
+import fs from 'fs';
+import os from 'os';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { v4 } from 'uuid';
+import request from '../../../../request.js';
+import { validation } from '../../../../utils/validation.js';
+import { cli } from '../../../../cli/cli.js';
+class SpoListItemBatchRemoveCommand extends SpoCommand {
+    get name() {
+        return commands.LISTITEM_BATCH_REMOVE;
+    }
+    get description() {
+        return 'Removes items from a list in batch';
+    }
+    constructor() {
+        super();
+        _SpoListItemBatchRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoListItemBatchRemoveCommand_instances, "m", _SpoListItemBatchRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoListItemBatchRemoveCommand_instances, "m", _SpoListItemBatchRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoListItemBatchRemoveCommand_instances, "m", _SpoListItemBatchRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoListItemBatchRemoveCommand_instances, "m", _SpoListItemBatchRemoveCommand_initTypes).call(this);
+        __classPrivateFieldGet(this, _SpoListItemBatchRemoveCommand_instances, "m", _SpoListItemBatchRemoveCommand_initOptionSets).call(this);
+    }
+    async commandAction(logger, args) {
+        const removeListItems = async () => {
+            try {
+                if (this.verbose) {
+                    logger.logToStderr('Removing the listitems from SharePoint...');
+                }
+                let idsToRemove = [];
+                if (args.options.filePath) {
+                    const csvContent = fs.readFileSync(args.options.filePath, 'utf-8');
+                    const jsonContent = formatting.parseCsvToJson(csvContent);
+                    idsToRemove = jsonContent.map((item) => item['ID']);
+                }
+                else {
+                    idsToRemove = formatting.splitAndTrim(args.options.ids);
+                }
+                await this.removeItemsAsBatch(idsToRemove, args.options, logger);
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        };
+        if (args.options.force) {
+            await removeListItems();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to ${args.options.recycle ? "recycle" : "remove"} the list items from list ${args.options.listId || args.options.listTitle || args.options.listUrl} located in site ${args.options.webUrl}?` });
+            if (result) {
+                await removeListItems();
+            }
+        }
+    }
+    async removeItemsAsBatch(items, options, logger) {
+        const itemsChunks = this.getChunkedArray(items, 10);
+        for (const [index, chunk] of itemsChunks.entries()) {
+            if (this.verbose) {
+                await logger.logToStderr(`Processing chunk ${index + 1} of ${itemsChunks.length}...`);
+            }
+            await this.postBatchData(chunk, options.webUrl, options);
+        }
+    }
+    async postBatchData(chunk, webUrl, options) {
+        const batchId = v4();
+        const requestBody = this.getRequestBody(chunk, batchId, options);
+        const requestOptions = {
+            url: `${webUrl}/_api/$batch`,
+            headers: {
+                'Content-Type': `multipart/mixed; boundary=batch_${batchId}`,
+                'Accept': 'application/json;odata=verbose'
+            },
+            data: requestBody.join('')
+        };
+        const response = await request.post(requestOptions);
+        const errors = this.parseBatchResponseBody(response, chunk);
+        if (errors.length > 0) {
+            throw `Creating some items failed with the following errors: ${os.EOL}${errors.map(error => { return `- ${error}`; }).join(os.EOL)}`;
+        }
+    }
+    getRequestBody(chunk, batchId, options) {
+        const changeSetId = v4();
+        const batchBody = [];
+        batchBody.push(`--batch_${batchId}\n`);
+        batchBody.push(`Content-Type: multipart/mixed; boundary="changeset_${changeSetId}"\n\n`);
+        batchBody.push('Content-Transfer-Encoding: binary\n\n');
+        for (const item of chunk) {
+            const actionUrl = this.getActionUrl(options, item);
+            batchBody.push(`--changeset_${changeSetId}\n`);
+            batchBody.push('Content-Type: application/http\n');
+            batchBody.push('Content-Transfer-Encoding: binary\n\n');
+            batchBody.push(`DELETE ${actionUrl} HTTP/1.1\n`);
+            batchBody.push(`Accept: application/json;odata=nometadata\n`);
+            batchBody.push(`If-Match: *\n\n`);
+        }
+        batchBody.push(`\n\n`);
+        batchBody.push(`--changeset_${changeSetId}--\n\n`);
+        batchBody.push(`--batch_${batchId}--\n`);
+        return batchBody;
+    }
+    parseBatchResponseBody(response, chunk) {
+        const errors = [];
+        response.split('\r\n')
+            .filter((line) => line.startsWith('{'))
+            .forEach((line, index) => {
+            const parsedResponse = JSON.parse(line);
+            if (parsedResponse.error) {
+                const error = parsedResponse.error;
+                errors.push(`Item ID ${chunk[index]}: ${error.message.value}`);
+            }
+        });
+        return errors;
+    }
+    ;
+    getChunkedArray(inputArray, chunkSize) {
+        const result = [];
+        for (let i = 0; i < inputArray.length; i += chunkSize) {
+            result.push(inputArray.slice(i, i + chunkSize));
+        }
+        return result;
+    }
+    getActionUrl(options, item) {
+        let requestUrl = '';
+        if (options.listId) {
+            requestUrl += `lists(guid'${formatting.encodeQueryParameter(options.listId)}')`;
+        }
+        else if (options.listTitle) {
+            requestUrl += `lists/getByTitle('${formatting.encodeQueryParameter(options.listTitle)}')`;
+        }
+        else if (options.listUrl) {
+            const listServerRelativeUrl = urlUtil.getServerRelativePath(options.webUrl, options.listUrl);
+            requestUrl += `GetList('${formatting.encodeQueryParameter(listServerRelativeUrl)}')`;
+        }
+        requestUrl += `/items(${item})`;
+        if (options.recycle) {
+            requestUrl += '/recycle()';
+        }
+        return requestUrl;
+    }
+}
+_SpoListItemBatchRemoveCommand_instances = new WeakSet(), _SpoListItemBatchRemoveCommand_initTelemetry = function _SpoListItemBatchRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            filePath: typeof args.options.filePath !== 'undefined',
+            ids: typeof args.options.ids !== 'undefined',
+            listId: typeof args.options.listId !== 'undefined',
+            listTitle: typeof args.options.listTitle !== 'undefined',
+            listUrl: typeof args.options.listUrl !== 'undefined',
+            recycle: !!args.options.recycle,
+            force: !!args.options.force
+        });
+    });
+}, _SpoListItemBatchRemoveCommand_initOptions = function _SpoListItemBatchRemoveCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --webUrl <webUrl>'
+    }, {
+        option: '-l, --listId [listId]'
+    }, {
+        option: '-t, --listTitle [listTitle]'
+    }, {
+        option: '--listUrl [listUrl]'
+    }, {
+        option: '-p, --filePath [filePath]'
+    }, {
+        option: '-i, --ids [ids]'
+    }, {
+        option: '-r, --recycle'
+    }, {
+        option: '-f, --force'
+    });
+}, _SpoListItemBatchRemoveCommand_initValidators = function _SpoListItemBatchRemoveCommand_initValidators() {
+    this.validators.push(async (args) => {
+        const isValidSharePointUrl = validation.isValidSharePointUrl(args.options.webUrl);
+        if (isValidSharePointUrl !== true) {
+            return isValidSharePointUrl;
+        }
+        if (args.options.listId &&
+            !validation.isValidGuid(args.options.listId)) {
+            return `${args.options.listId} in option listId is not a valid GUID.`;
+        }
+        if (args.options.filePath) {
+            if (!fs.existsSync(args.options.filePath)) {
+                return `File with path ${args.options.filePath} does not exist.`;
+            }
+            const fileContent = fs.readFileSync(args.options.filePath, 'utf-8');
+            const jsonContent = formatting.parseCsvToJson(fileContent);
+            if (!jsonContent[0].hasOwnProperty('ID')) {
+                return `The file does not contain the required header row with the column name 'ID'.`;
+            }
+            const nonNumbers = jsonContent.filter(element => isNaN(Number(element['ID'].toString().trim()))).map(element => element['ID']);
+            if (nonNumbers.length > 0) {
+                return `The specified ids '${nonNumbers.join(', ')}' are invalid numbers.`;
+            }
+        }
+        if (args.options.ids) {
+            const nonNumbers = formatting.splitAndTrim(args.options.ids).filter(element => isNaN(Number(element)));
+            if (nonNumbers.length > 0) {
+                return `The specified ids '${nonNumbers.join(', ')}' are invalid numbers.`;
+            }
+        }
+        return true;
+    });
+}, _SpoListItemBatchRemoveCommand_initTypes = function _SpoListItemBatchRemoveCommand_initTypes() {
+    this.types.string.push('webUrl', 'listId', 'listTitle', 'listUrl', 'ids', 'filePath');
+}, _SpoListItemBatchRemoveCommand_initOptionSets = function _SpoListItemBatchRemoveCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['listId', 'listTitle', 'listUrl']
+    }, {
+        options: ['filePath', 'ids']
+    });
+};
+export default new SpoListItemBatchRemoveCommand();
+//# sourceMappingURL=listitem-batch-remove.js.map

package/dist/m365/spo/commands/navigation/navigation-node-add.js

@@ -135,8 +135,9 @@ _SpoNavigationNodeAddCommand_instances = new WeakSet(), _SpoNavigationNodeAddCom
             if (audienceIdsSplitted.length > 10) {
                 return 'The maximum amount of audienceIds per navigation node exceeded. The maximum amount of auciendeIds is 10.';
             }
-            if (!validation.isValidGuidArray(audienceIdsSplitted)) {
-                return 'The option audienceIds contains one or more invalid GUIDs';
+            const isValidGUIDArrayResult = validation.isValidGuidArray(args.options.audienceIds);
+            if (isValidGUIDArrayResult !== true) {
+                return `The following GUIDs are invalid for the option 'audienceIds': ${isValidGUIDArrayResult}.`;
             }
         }
         return true;

package/dist/m365/spo/commands/navigation/navigation-node-set.js

@@ -127,8 +127,9 @@ _SpoNavigationNodeSetCommand_instances = new WeakSet(), _SpoNavigationNodeSetCom
             if (audienceIdsSplitted.length > 10) {
                 return 'The maximum amount of audienceIds per navigation node exceeded. The maximum amount of audienceIds is 10.';
             }
-            if (!validation.isValidGuidArray(audienceIdsSplitted)) {
-                return `The option audienceIds contains one or more invalid GUIDs`;
+            const isValidGUIDArrayResult = validation.isValidGuidArray(args.options.audienceIds);
+            if (isValidGUIDArrayResult !== true) {
+                return `The following GUIDs are invalid for the option 'audienceIds': ${isValidGUIDArrayResult}.`;
             }
         }
         return true;

package/dist/m365/spo/commands/site/site-recyclebinitem-move.js

@@ -89,8 +89,11 @@ _SpoSiteRecycleBinItemMoveCommand_instances = new WeakSet(), _SpoSiteRecycleBinI
         if (isValidSharePointUrl !== true) {
             return isValidSharePointUrl;
         }
-        if (args.options.ids && !validation.isValidGuidArray(args.options.ids.split(','))) {
-            return 'The option ids contains one or more invalid GUIDs';
+        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}.`;
+            }
         }
         return true;
     });

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

@@ -76,8 +76,9 @@ _SpoSiteRecycleBinItemRemoveCommand_instances = new WeakSet(), _SpoSiteRecycleBi
         if (isValidSharePointUrl !== true) {
             return isValidSharePointUrl;
         }
-        if (!validation.isValidGuidArray(args.options.ids.split(','))) {
-            return 'The option ids contains one or more invalid GUIDs.';
+        const isValidGUIDArrayResult = validation.isValidGuidArray(args.options.ids);
+        if (isValidGUIDArrayResult !== true) {
+            return `The following GUIDs are invalid for the option 'ids': ${isValidGUIDArrayResult}.`;
         }
         return true;
     });