@pnp/cli-microsoft365 7.2.0 → 7.3.0-beta.01256d2

package/dist/appInsights.js

@@ -25,6 +25,7 @@ appInsightsClient.commonProperties = {
     ci: Boolean(process.env.CI).toString()
 };
 appInsightsClient.context.tags['ai.cloud.roleInstance'] = crypto.createHash('sha256').update(appInsightsClient.context.tags['ai.cloud.roleInstance']).digest('hex');
-appInsightsClient.context.tags['ai.cloud.role'];
+delete appInsightsClient.context.tags['ai.cloud.role'];
+delete appInsightsClient.context.tags['ai.cloud.roleName'];
 export default appInsightsClient;
 //# sourceMappingURL=appInsights.js.map

package/dist/cli/Cli.js

@@ -100,43 +100,44 @@ export class Cli {
             }
             return Promise.resolve();
         }
-        const optionsWithoutShorts = Cli.removeShortOptions(this.optionsFromArgs);
+        delete this.optionsFromArgs.options._;
+        delete this.optionsFromArgs.options['--'];
         try {
             // replace values staring with @ with file contents
-            Cli.loadOptionValuesFromFiles(optionsWithoutShorts);
+            Cli.loadOptionValuesFromFiles(this.optionsFromArgs);
         }
         catch (e) {
-            return this.closeWithError(e, optionsWithoutShorts);
+            return this.closeWithError(e, this.optionsFromArgs);
         }
         const startProcessing = process.hrtime.bigint();
         try {
             // process options before passing them on to validation stage
-            const contextCommandOptions = await this.loadOptionsFromContext(this.commandToExecute.options, optionsWithoutShorts.options.debug);
-            optionsWithoutShorts.options = { ...contextCommandOptions, ...optionsWithoutShorts.options };
-            await this.commandToExecute.command.processOptions(optionsWithoutShorts.options);
+            const contextCommandOptions = await this.loadOptionsFromContext(this.commandToExecute.options, this.optionsFromArgs.options.debug);
+            this.optionsFromArgs.options = { ...contextCommandOptions, ...this.optionsFromArgs.options };
+            await this.commandToExecute.command.processOptions(this.optionsFromArgs.options);
             const endProcessing = process.hrtime.bigint();
             timings.options.push(Number(endProcessing - startProcessing));
         }
         catch (e) {
             const endProcessing = process.hrtime.bigint();
             timings.options.push(Number(endProcessing - startProcessing));
-            return this.closeWithError(e.message, optionsWithoutShorts, false);
+            return this.closeWithError(e.message, this.optionsFromArgs, false);
         }
         // if output not specified, set the configured output value (if any)
-        if (optionsWithoutShorts.options.output === undefined) {
-            optionsWithoutShorts.options.output = this.getSettingWithDefaultValue(settingsNames.output, 'json');
+        if (this.optionsFromArgs.options.output === undefined) {
+            this.optionsFromArgs.options.output = this.getSettingWithDefaultValue(settingsNames.output, 'json');
         }
         const startValidation = process.hrtime.bigint();
-        const validationResult = await this.commandToExecute.command.validate(optionsWithoutShorts, this.commandToExecute);
+        const validationResult = await this.commandToExecute.command.validate(this.optionsFromArgs, this.commandToExecute);
         const endValidation = process.hrtime.bigint();
         timings.validation.push(Number(endValidation - startValidation));
         if (validationResult !== true) {
-            return this.closeWithError(validationResult, optionsWithoutShorts, true);
+            return this.closeWithError(validationResult, this.optionsFromArgs, true);
         }
         const end = process.hrtime.bigint();
         timings.core.push(Number(end - start));
         try {
-            await Cli.executeCommand(this.commandToExecute.command, optionsWithoutShorts);
+            await Cli.executeCommand(this.commandToExecute.command, this.optionsFromArgs);
             const endTotal = process.hrtime.bigint();
             timings.total.push(Number(endTotal - start));
             this.printTimings(rawArgs);
@@ -146,7 +147,7 @@ export class Cli {
             const endTotal = process.hrtime.bigint();
             timings.total.push(Number(endTotal - start));
             this.printTimings(rawArgs);
-            await this.closeWithError(err, optionsWithoutShorts);
+            await this.closeWithError(err, this.optionsFromArgs);
             /* c8 ignore next */
         }
     }

package/dist/index.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import { Cli } from './cli/Cli.js';
-import { telemetry } from './telemetry.js';
 import { app } from './utils/app.js';
 // required to make console.log() in combination with piped output synchronous
 // on Windows/in PowerShell so that the output is not trimmed by calling
@@ -14,12 +13,5 @@ if (!process.env.CLIMICROSOFT365_NOUPDATE) {
         updateNotifier.default({ pkg: app.packageJson() }).notify({ defer: false });
     });
 }
-try {
-    const cli = Cli.getInstance();
-    cli.execute(process.argv.slice(2));
-}
-catch (e) {
-    telemetry.trackException(e);
-    process.exit(1);
-}
+Cli.getInstance().execute(process.argv.slice(2));
 //# sourceMappingURL=index.js.map

package/dist/m365/aad/commands/group/group-list.js

@@ -1,3 +1,9 @@
+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 _AadGroupListCommand_instances, _a, _AadGroupListCommand_initTelemetry, _AadGroupListCommand_initOptions, _AadGroupListCommand_initValidators;
 import { Cli } from '../../../../cli/Cli.js';
 import { odata } from '../../../../utils/odata.js';
 import GraphCommand from '../../../base/GraphCommand.js';
@@ -12,9 +18,51 @@ class AadGroupListCommand extends GraphCommand {
     defaultProperties() {
         return ['id', 'displayName', 'groupType'];
     }
+    constructor() {
+        super();
+        _AadGroupListCommand_instances.add(this);
+        __classPrivateFieldGet(this, _AadGroupListCommand_instances, "m", _AadGroupListCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _AadGroupListCommand_instances, "m", _AadGroupListCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _AadGroupListCommand_instances, "m", _AadGroupListCommand_initValidators).call(this);
+    }
     async commandAction(logger, args) {
         try {
-            const groups = await odata.getAllItems(`${this.resource}/v1.0/groups`);
+            let requestUrl = `${this.resource}/v1.0/groups`;
+            let useConsistencyLevelHeader = false;
+            if (args.options.type) {
+                const groupType = _a.groupTypes.find(g => g.toLowerCase() === args.options.type?.toLowerCase());
+                switch (groupType) {
+                    case 'microsoft365':
+                        requestUrl += `?$filter=groupTypes/any(c:c+eq+'Unified')`;
+                        break;
+                    case 'security':
+                        requestUrl += '?$filter=securityEnabled eq true and mailEnabled eq false';
+                        break;
+                    case 'distribution':
+                        requestUrl += '?$filter=securityEnabled eq false and mailEnabled eq true';
+                        break;
+                    case 'mailEnabledSecurity':
+                        useConsistencyLevelHeader = true;
+                        requestUrl += `?$filter=securityEnabled eq true and mailEnabled eq true and not(groupTypes/any(t:t eq 'Unified'))&$count=true`;
+                        break;
+                }
+            }
+            let groups = [];
+            if (useConsistencyLevelHeader) {
+                // While using not() function in the filter, we need to specify the ConsistencyLevel header.
+                const requestOptions = {
+                    url: requestUrl,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none',
+                        ConsistencyLevel: 'eventual'
+                    },
+                    responseType: 'json'
+                };
+                groups = await odata.getAllItems(requestOptions);
+            }
+            else {
+                groups = await odata.getAllItems(requestUrl);
+            }
             if (Cli.shouldTrimOutput(args.options.output)) {
                 groups.forEach((group) => {
                     if (group.groupTypes && group.groupTypes.length > 0 && group.groupTypes[0] === 'Unified') {
@@ -38,5 +86,25 @@ class AadGroupListCommand extends GraphCommand {
         }
     }
 }
+_a = AadGroupListCommand, _AadGroupListCommand_instances = new WeakSet(), _AadGroupListCommand_initTelemetry = function _AadGroupListCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            type: typeof args.options.type !== 'undefined'
+        });
+    });
+}, _AadGroupListCommand_initOptions = function _AadGroupListCommand_initOptions() {
+    this.options.unshift({
+        option: '--type [type]',
+        autocomplete: _a.groupTypes
+    });
+}, _AadGroupListCommand_initValidators = function _AadGroupListCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.type && _a.groupTypes.every(g => g.toLowerCase() !== args.options.type?.toLowerCase())) {
+            return `${args.options.type} is not a valid type value. Allowed values microsoft365|security|distribution|mailEnabledSecurity.`;
+        }
+        return true;
+    });
+};
+AadGroupListCommand.groupTypes = ['microsoft365', 'security', 'distribution', 'mailEnabledSecurity'];
 export default new AadGroupListCommand();
 //# sourceMappingURL=group-list.js.map

package/dist/m365/external/commands/connection/connection-doctor.js

@@ -0,0 +1,424 @@
+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 _ExternalConnectionDoctorCommand_instances, _a, _ExternalConnectionDoctorCommand_initOptions, _ExternalConnectionDoctorCommand_initValidators;
+import os from 'os';
+import { Cli } from '../../../../cli/Cli.js';
+import request from '../../../../request.js';
+import { settingsNames } from '../../../../settingsNames.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class ExternalConnectionDoctorCommand extends GraphCommand {
+    get name() {
+        return commands.CONNECTION_DOCTOR;
+    }
+    get description() {
+        return 'Checks if the external connection is correctly configured for use with the specified Microsoft 365 experience';
+    }
+    constructor() {
+        super();
+        _ExternalConnectionDoctorCommand_instances.add(this);
+        this.checksStatus = [];
+        __classPrivateFieldGet(this, _ExternalConnectionDoctorCommand_instances, "m", _ExternalConnectionDoctorCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _ExternalConnectionDoctorCommand_instances, "m", _ExternalConnectionDoctorCommand_initValidators).call(this);
+    }
+    async commandAction(logger, args) {
+        const ux = args.options.ux ?? 'all';
+        const output = args.options.output;
+        this.checksStatus = [];
+        const cli = Cli.getInstance();
+        const showSpinner = cli.getSettingWithDefaultValue(settingsNames.showSpinner, true) &&
+            output === 'text' &&
+            typeof global.it === 'undefined';
+        let checks = [
+            {
+                id: 'loadExternalConnection',
+                text: 'Load connection',
+                fn: this.loadConnection,
+                type: 'required'
+            },
+            {
+                id: 'loadSchema',
+                text: 'Load schema',
+                fn: this.loadSchema,
+                type: 'required'
+            }
+        ];
+        if (ux === 'copilot' || ux === 'all') {
+            checks.push({
+                id: 'copilotRequiredSemanticLabels',
+                text: 'Required semantic labels',
+                fn: this.checkCopilotRequiredSemanticLabels,
+                type: 'required'
+            }, {
+                id: 'searchableProperties',
+                text: 'Searchable properties',
+                fn: this.checkSearchableProperties,
+                type: 'required'
+            }, {
+                id: 'contentIngested',
+                text: 'Items have content ingested',
+                fn: this.checkContentIngested,
+                type: 'required'
+            }, {
+                id: 'enabledForInlineResults',
+                text: 'Connection configured for inline results',
+                type: 'required'
+            }, {
+                id: 'itemsHaveActivities',
+                text: 'Items have activities recorded',
+                type: 'recommended'
+            }, {
+                id: 'meaningfulNameAndDescription',
+                text: 'Meaningful connection name and description',
+                type: 'required'
+            });
+        }
+        if (ux === 'search' || ux === 'all') {
+            checks.push({
+                id: 'semanticLabels',
+                text: 'Semantic labels',
+                fn: this.checkSemanticLabels,
+                type: 'recommended'
+            }, {
+                id: 'searchableProperties',
+                text: 'Searchable properties',
+                fn: this.checkSearchableProperties,
+                type: 'recommended'
+            }, {
+                id: 'resultType',
+                text: 'Result type',
+                fn: this.checkResultType,
+                type: 'recommended'
+            }, {
+                id: 'contentIngested',
+                text: 'Items have content ingested',
+                fn: this.checkContentIngested,
+                type: 'recommended'
+            }, {
+                id: 'itemsHaveActivities',
+                text: 'Items have activities recorded',
+                type: 'recommended'
+            });
+        }
+        checks.push({
+            id: 'urlToItemResolver',
+            text: 'urlToItemResolver configured',
+            fn: this.checkUrlToItemResolverConfigured,
+            type: 'recommended'
+        });
+        // filter out duplicate checks based on their IDs
+        checks = checks.filter((check, index, self) => self.findIndex(c => c.id === check.id) === index);
+        for (const check of checks) {
+            if (this.debug) {
+                logger.logToStderr(`Running check ${check.id}...`);
+            }
+            // don't show spinner if running tests
+            /* c8 ignore next 3 */
+            if (showSpinner) {
+                cli.spinner.start(check.text);
+            }
+            // only automated checks have functions
+            if (!check.fn) {
+                // don't show spinner if running tests
+                /* c8 ignore next 3 */
+                if (showSpinner) {
+                    cli.spinner.info(`${check.text} (manual)`);
+                }
+                this.checksStatus.push({
+                    ...check,
+                    status: 'manual'
+                });
+                continue;
+            }
+            const result = await check.fn.bind(this)(check.id, args);
+            this.checksStatus.push({ ...check, ...result });
+            if (result.status === 'passed') {
+                // don't show spinner if running tests
+                /* c8 ignore next 3 */
+                if (showSpinner) {
+                    cli.spinner.succeed();
+                }
+                continue;
+            }
+            if (result.status === 'failed') {
+                // don't show spinner if running tests
+                /* c8 ignore next 9 */
+                if (showSpinner) {
+                    const message = `${check.text}: ${result.errorMessage}`;
+                    if (check.type === 'required') {
+                        cli.spinner.fail(message);
+                    }
+                    else {
+                        cli.spinner.warn(message);
+                    }
+                }
+                if (result.shouldStop) {
+                    break;
+                }
+            }
+        }
+        if (output === 'text' || output === 'none') {
+            return;
+        }
+        this.checksStatus.forEach(s => {
+            delete s.data;
+            delete s.fn;
+            delete s.shouldStop;
+        });
+        if (output === 'json' || output === 'md') {
+            await logger.log(this.checksStatus);
+            return;
+        }
+        if (output === 'csv') {
+            this.checksStatus.forEach(r => {
+                // we need to set errorMessage to empty string so that it's not
+                // removed from the CSV output
+                r.errorMessage = r.errorMessage ?? '';
+            });
+            await logger.log(this.checksStatus);
+        }
+    }
+    getMdOutput(logStatement, command, options) {
+        const output = [
+            `# ${command.getCommandName()} ${Object.keys(options).filter(o => o !== 'output').map(k => `--${k} "${options[k]}"`).join(' ')}`, os.EOL,
+            os.EOL,
+            `Date: ${(new Date().toLocaleDateString())}`, os.EOL,
+            os.EOL
+        ];
+        if (logStatement && logStatement.length > 0) {
+            const properties = ['text', 'type', 'status', 'errorMessage'];
+            output.push('Check|Type|Status|Error message', os.EOL);
+            output.push(':----|:--:|:----:|:------------', os.EOL);
+            logStatement.forEach(r => {
+                output.push(properties.map(p => r[p] ?? '').join('|'), os.EOL);
+            });
+            logStatement.push(os.EOL);
+        }
+        return output.join('').trimEnd();
+    }
+    async loadConnection(id, args) {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/external/connections/${args.options.id}`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        try {
+            const externalConnection = await request.get(requestOptions);
+            return {
+                id,
+                data: externalConnection,
+                status: 'passed'
+            };
+        }
+        catch (ex) {
+            return {
+                id,
+                error: ex?.response?.data?.error?.innerError?.message,
+                errorMessage: 'Connection not found',
+                shouldStop: true,
+                status: 'failed'
+            };
+        }
+    }
+    async loadSchema(id, args) {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/external/connections/${args.options.id}/schema`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        try {
+            const schema = await request.get(requestOptions);
+            return {
+                id,
+                data: schema,
+                status: 'passed'
+            };
+        }
+        catch (ex) {
+            return {
+                id,
+                errorMessage: 'Schema not found',
+                error: ex?.response?.data?.error?.innerError?.message,
+                shouldStop: true,
+                status: 'failed'
+            };
+        }
+    }
+    async checkCopilotRequiredSemanticLabels(id) {
+        const schema = this.checksStatus.find(r => r.id === 'loadSchema').data;
+        const requiredLabels = ['title', 'url', 'iconUrl'];
+        for (const label of requiredLabels) {
+            if (!schema.properties?.find(p => p.labels?.find(l => l.toString() === label))) {
+                return {
+                    id,
+                    errorMessage: `Missing label ${label}`,
+                    status: 'failed'
+                };
+            }
+        }
+        return {
+            id,
+            status: 'passed'
+        };
+    }
+    async checkSearchableProperties(id) {
+        const schema = this.checksStatus.find(r => r.id === 'loadSchema').data;
+        if (!schema.properties?.some(p => p.isSearchable)) {
+            return {
+                id,
+                errorMessage: 'Schema does not have any searchable properties',
+                status: 'failed'
+            };
+        }
+        return {
+            id,
+            status: 'passed'
+        };
+    }
+    async checkContentIngested(id, args) {
+        try {
+            // find items that belong to the connection
+            const searchRequestOptions = {
+                url: `${this.resource}/v1.0/search/query`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json',
+                data: {
+                    requests: [
+                        {
+                            entityTypes: [
+                                'externalItem'
+                            ],
+                            contentSources: [
+                                `/external/connections/${args.options.id}`
+                            ],
+                            query: {
+                                queryString: '*'
+                            },
+                            from: 0,
+                            size: 1
+                        }
+                    ]
+                }
+            };
+            const result = await request.post(searchRequestOptions);
+            const hit = result.value?.[0].hitsContainers?.[0]?.hits?.[0];
+            if (!hit) {
+                return {
+                    id,
+                    errorMessage: 'No items found that belong to the connection',
+                    status: 'failed'
+                };
+            }
+            // something@tenant,itemId
+            const itemId = hit.resource?.properties?.substrateContentDomainId?.split(',')?.[1];
+            if (!itemId) {
+                return {
+                    id,
+                    errorMessage: 'Item does not have substrateContentDomainId property or the property is invalid',
+                    status: 'failed'
+                };
+            }
+            const externalItemRequestOptions = {
+                url: `${this.resource}/v1.0/external/connections/${args.options.id}/items/${itemId}`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json'
+            };
+            const externalItem = await request.get(externalItemRequestOptions);
+            if (!externalItem.content?.value) {
+                return {
+                    id,
+                    data: externalItem,
+                    errorMessage: 'Item does not have content or content is empty',
+                    status: 'failed'
+                };
+            }
+            return {
+                id,
+                data: externalItem,
+                status: 'passed'
+            };
+        }
+        catch (ex) {
+            return {
+                id,
+                error: ex?.response?.data?.error?.innerError?.message,
+                errorMessage: 'Error while checking if content is ingested',
+                status: 'failed'
+            };
+        }
+    }
+    async checkUrlToItemResolverConfigured(id) {
+        const externalConnection = this.checksStatus.find(r => r.id === 'loadExternalConnection').data;
+        if (!externalConnection.activitySettings?.urlToItemResolvers?.some(r => r)) {
+            return {
+                id,
+                errorMessage: 'urlToItemResolver is not configured',
+                status: 'failed'
+            };
+        }
+        return {
+            id,
+            status: 'passed'
+        };
+    }
+    async checkSemanticLabels(id) {
+        const schema = this.checksStatus.find(r => r.id === 'loadSchema').data;
+        const hasLabels = schema.properties?.some(p => p.labels?.some(l => l));
+        if (!hasLabels) {
+            return {
+                id,
+                errorMessage: `Schema does not have semantic labels`,
+                status: 'failed'
+            };
+        }
+        return {
+            id,
+            status: 'passed'
+        };
+    }
+    async checkResultType(id) {
+        const externalConnection = this.checksStatus.find(r => r.id === 'loadExternalConnection').data;
+        if (!externalConnection.searchSettings?.searchResultTemplates?.some(t => t)) {
+            return {
+                id,
+                errorMessage: `Connection has no result types`,
+                status: 'failed'
+            };
+        }
+        return {
+            id,
+            status: 'passed'
+        };
+    }
+}
+_a = ExternalConnectionDoctorCommand, _ExternalConnectionDoctorCommand_instances = new WeakSet(), _ExternalConnectionDoctorCommand_initOptions = function _ExternalConnectionDoctorCommand_initOptions() {
+    this.options.unshift({
+        option: '-i, --id <id>'
+    }, {
+        option: '--ux [ux]',
+        autocomplete: _a.supportedUx
+    });
+}, _ExternalConnectionDoctorCommand_initValidators = function _ExternalConnectionDoctorCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.ux) {
+            if (!_a.supportedUx.find(u => u === args.options.ux)) {
+                return `${args.options.ux} is not a valid UX. Allowed values are ${_a.supportedUx.join(', ')}`;
+            }
+        }
+        return true;
+    });
+};
+ExternalConnectionDoctorCommand.supportedUx = ['copilot', 'search', 'all'];
+export default new ExternalConnectionDoctorCommand();
+//# sourceMappingURL=connection-doctor.js.map