@pnp/cli-microsoft365 6.0.0-beta.27e1012 → 6.0.0-beta.2ab70db

package/.devcontainer/Dockerfile

@@ -27,7 +27,9 @@ RUN apt-get update && apt-get install -y \
   && apt-get install nodejs -y \
   && rm -rf /var/lib/apt/lists/*
 
-RUN pip3 install mkdocs-material==7.1.7 pymdown-extensions==9.0 pygments==2.11
+COPY ../docs/pip_requirements.txt .
+
+RUN pip install -r pip_requirements.txt
 
 RUN useradd \
   --user-group \

package/.devcontainer/devcontainer.json

@@ -1,6 +1,7 @@
 {
   "name": "CLI for Microsoft 365",
   "dockerFile": "Dockerfile",
+  "context": "..",
   "settings": {
     "terminal.integrated.profiles.linux": {
       "zsh": {

package/dist/Auth.js

@@ -301,8 +301,7 @@ class Auth {
             logger.logToStderr('');
         }
         logger.log(response.message);
-        if (cli_1.Cli.getInstance().getSettingWithDefaultValue(settingsNames_1.settingsNames.autoOpenBrowserOnLogin, false)
-            || cli_1.Cli.getInstance().getSettingWithDefaultValue(settingsNames_1.settingsNames.autoOpenLinksInBrowser, false)) {
+        if (cli_1.Cli.getInstance().getSettingWithDefaultValue(settingsNames_1.settingsNames.autoOpenLinksInBrowser, false)) {
             // _open is never set before hitting this line, but this check
             // is implemented so that we can support lazy loading
             // but also stub it for testing

package/dist/Command.js

@@ -8,12 +8,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+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 _Command_instances, _Command_initTelemetry, _Command_initOptions, _Command_initValidators;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandErrorWithOutput = exports.CommandError = void 0;
+const os = require("os");
 const appInsights_1 = require("./appInsights");
 const Auth_1 = require("./Auth");
 const cli_1 = require("./cli");
 const request_1 = require("./request");
+const settingsNames_1 = require("./settingsNames");
 const utils_1 = require("./utils");
 class CommandError {
     constructor(message, code) {
@@ -31,77 +39,105 @@ class CommandErrorWithOutput {
 exports.CommandErrorWithOutput = CommandErrorWithOutput;
 class Command {
     constructor() {
-        this._debug = false;
-        this._verbose = false;
-    }
-    get debug() {
-        return this._debug;
-    }
-    get verbose() {
-        return this._verbose;
-    }
-    showDeprecationWarning(logger, deprecated, recommended) {
-        const cli = cli_1.Cli.getInstance();
-        if (cli.currentCommandName &&
-            cli.currentCommandName.indexOf(deprecated) === 0) {
-            const chalk = require('chalk');
-            logger.logToStderr(chalk.yellow(`Command '${deprecated}' is deprecated. Please use '${recommended}' instead`));
-        }
-    }
-    warn(logger, warning) {
-        const chalk = require('chalk');
-        logger.logToStderr(chalk.yellow(warning));
+        // These functions must be defined with # so that they're truly private
+        // otherwise you'll get a ts2415 error (Types have separate declarations of
+        // a private property 'x'.).
+        // `private` in TS is a design-time flag and private members end-up being
+        // regular class properties that would collide on runtime, which is why we
+        // need the extra `#`
+        _Command_instances.add(this);
+        this.debug = false;
+        this.verbose = false;
+        this.telemetry = [];
+        this.telemetryProperties = {};
+        this.options = [];
+        this.optionSets = [];
+        this.types = {
+            boolean: [],
+            string: []
+        };
+        this.validators = [];
+        __classPrivateFieldGet(this, _Command_instances, "m", _Command_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _Command_instances, "m", _Command_initOptions).call(this);
+        __classPrivateFieldGet(this, _Command_instances, "m", _Command_initValidators).call(this);
     }
-    getUsedCommandName() {
-        const cli = cli_1.Cli.getInstance();
-        const commandName = this.getCommandName();
-        if (!cli.currentCommandName) {
-            return commandName;
-        }
-        if (cli.currentCommandName &&
-            cli.currentCommandName.indexOf(commandName) === 0) {
-            return commandName;
-        }
-        // since the command was called by something else than its name
-        // it must have aliases
-        const aliases = this.alias();
-        for (let i = 0; i < aliases.length; i++) {
-            if (cli.currentCommandName.indexOf(aliases[i]) === 0) {
-                return aliases[i];
+    validateUnknownOptions(args, command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.allowUnknownOptions()) {
+                return true;
             }
-        }
-        // shouldn't happen because the command is called either by its name or alias
-        return '';
+            // if the command doesn't allow unknown options, check if all specified
+            // options match command options
+            for (const optionFromArgs in args.options) {
+                let matches = false;
+                for (let i = 0; i < command.options.length; i++) {
+                    const option = command.options[i];
+                    if (optionFromArgs === option.long ||
+                        optionFromArgs === option.short) {
+                        matches = true;
+                        break;
+                    }
+                }
+                if (!matches) {
+                    return `Invalid option: '${optionFromArgs}'${os.EOL}`;
+                }
+            }
+            return true;
+        });
     }
-    action(logger, args, cb) {
-        Auth_1.default
-            .restoreAuth()
-            .then(() => {
-            this.initAction(args, logger);
-            if (!Auth_1.default.service.connected) {
-                cb(new CommandError('Log in to Microsoft 365 first'));
-                return;
+    validateRequiredOptions(args, command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const shouldPrompt = cli_1.Cli.getInstance().getSettingWithDefaultValue(settingsNames_1.settingsNames.prompt, false);
+            let inquirer;
+            let prompted = false;
+            for (let i = 0; i < command.options.length; i++) {
+                if (!command.options[i].required ||
+                    typeof args.options[command.options[i].name] !== 'undefined') {
+                    continue;
+                }
+                if (!shouldPrompt) {
+                    return `Required option ${command.options[i].name} not specified`;
+                }
+                if (!prompted) {
+                    prompted = true;
+                    cli_1.Cli.log('Provide values for the following parameters:');
+                }
+                if (!inquirer) {
+                    inquirer = require('inquirer');
+                }
+                const missingRequireOptionValue = yield inquirer
+                    .prompt({
+                    name: 'missingRequireOptionValue',
+                    message: `${command.options[i].name}: `
+                })
+                    .then(result => result.missingRequireOptionValue);
+                args.options[command.options[i].name] = missingRequireOptionValue;
             }
-            this.loadValuesFromAccessToken(args);
-            this.commandAction(logger, args, cb);
-        }, (error) => {
-            cb(new CommandError(error));
+            return true;
         });
     }
-    getTelemetryProperties(args) {
-        return {
-            debug: this.debug.toString(),
-            verbose: this.verbose.toString(),
-            output: args.options.output,
-            query: typeof args.options.query !== 'undefined'
-        };
+    validateOptionSets(args, command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const optionsSets = command.command.optionSets;
+            if (!optionsSets || optionsSets.length === 0) {
+                return true;
+            }
+            const argsOptions = Object.keys(args.options);
+            for (const optionSet of optionsSets) {
+                const commonOptions = argsOptions.filter(opt => optionSet.includes(opt));
+                if (commonOptions.length === 0) {
+                    return `Specify one of the following options: ${optionSet.map(opt => opt).join(', ')}.`;
+                }
+                if (commonOptions.length > 1) {
+                    return `Specify one of the following options: ${optionSet.map(opt => opt).join(', ')}, but not multiple.`;
+                }
+            }
+            return true;
+        });
     }
     alias() {
         return;
     }
-    autocomplete() {
-        return;
-    }
     /**
      * Returns list of properties that should be returned in the text output.
      * Returns all properties if no default properties specified
@@ -112,33 +148,6 @@ class Command {
     allowUnknownOptions() {
         return;
     }
-    options() {
-        return [
-            {
-                option: '--query [query]'
-            },
-            {
-                option: '-o, --output [output]',
-                autocomplete: ['csv', 'json', 'text']
-            },
-            {
-                option: '--verbose'
-            },
-            {
-                option: '--debug'
-            }
-        ];
-    }
-    optionSets() {
-        return;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    validate(args) {
-        return true;
-    }
-    types() {
-        return;
-    }
     /**
      * Processes options after resolving them from the user input and before
      * passing them on to command action for execution. Used for example for
@@ -150,6 +159,41 @@ class Command {
         return __awaiter(this, void 0, void 0, function* () {
         });
     }
+    action(logger, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield Auth_1.default.restoreAuth();
+            }
+            catch (error) {
+                throw new CommandError(error);
+            }
+            this.initAction(args, logger);
+            if (!Auth_1.default.service.connected) {
+                throw new CommandError('Log in to Microsoft 365 first');
+            }
+            try {
+                this.loadValuesFromAccessToken(args);
+                yield this.commandAction(logger, args);
+            }
+            catch (ex) {
+                if (ex instanceof CommandError) {
+                    throw ex;
+                }
+                throw new CommandError(ex);
+            }
+        });
+    }
+    validate(args, command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const validate of this.validators) {
+                const result = yield validate(args, command);
+                if (result !== true) {
+                    return result;
+                }
+            }
+            return true;
+        });
+    }
     getCommandName(alias) {
         var _a;
         if (alias &&
@@ -167,92 +211,100 @@ class Command {
         }
         return commandName;
     }
-    handleRejectedODataPromise(rawResponse, logger, callback) {
+    handleRejectedODataPromise(rawResponse) {
         const res = JSON.parse(JSON.stringify(rawResponse));
         if (res.error) {
             try {
                 const err = JSON.parse(res.error);
-                callback(new CommandError(err['odata.error'].message.value));
+                throw new CommandError(err['odata.error'].message.value);
             }
-            catch (_a) {
+            catch (err) {
+                if (err instanceof CommandError) {
+                    throw err;
+                }
                 try {
                     const graphResponseError = res.error;
                     if (graphResponseError.error.code) {
-                        callback(new CommandError(graphResponseError.error.code + " - " + graphResponseError.error.message));
+                        throw new CommandError(graphResponseError.error.code + " - " + graphResponseError.error.message);
                     }
                     else {
-                        callback(new CommandError(graphResponseError.error.message));
+                        throw new CommandError(graphResponseError.error.message);
                     }
                 }
-                catch (_b) {
-                    callback(new CommandError(res.error));
+                catch (err) {
+                    if (err instanceof CommandError) {
+                        throw err;
+                    }
+                    throw new CommandError(res.error);
                 }
             }
         }
         else {
             if (rawResponse instanceof Error) {
-                callback(new CommandError(rawResponse.message));
+                throw new CommandError(rawResponse.message);
             }
             else {
-                callback(new CommandError(rawResponse));
+                throw new CommandError(rawResponse);
             }
         }
     }
-    handleRejectedODataJsonPromise(response, logger, callback) {
-        // console.log(JSON.stringify(response, null, 2));
+    handleRejectedODataJsonPromise(response) {
         if (response.error &&
             response.error['odata.error'] &&
             response.error['odata.error'].message) {
-            return callback(new CommandError(response.error['odata.error'].message.value));
+            throw new CommandError(response.error['odata.error'].message.value);
         }
         if (!response.error) {
             if (response instanceof Error) {
-                return callback(new CommandError(response.message));
+                throw new CommandError(response.message);
             }
             else {
-                return callback(new CommandError(response));
+                throw new CommandError(response);
             }
         }
         if (response.error.error &&
             response.error.error.message) {
-            return callback(new CommandError(response.error.error.message));
+            throw new CommandError(response.error.error.message);
         }
         if (response.error.message) {
-            return callback(new CommandError(response.error.message));
+            throw new CommandError(response.error.message);
         }
         if (response.error.error_description) {
-            return callback(new CommandError(response.error.error_description));
+            throw new CommandError(response.error.error_description);
         }
         try {
             const error = JSON.parse(response.error);
             if (error &&
                 error.error &&
                 error.error.message) {
-                callback(new CommandError(error.error.message));
+                throw new CommandError(error.error.message);
             }
             else {
-                callback(new CommandError(response.error));
+                throw new CommandError(response.error);
             }
         }
-        catch (_a) {
-            callback(new CommandError(response.error));
+        catch (err) {
+            if (err instanceof CommandError) {
+                throw err;
+            }
+            throw new CommandError(response.error);
         }
     }
-    handleError(rawResponse, logger, callback) {
+    handleError(rawResponse) {
         if (rawResponse instanceof Error) {
-            callback(new CommandError(rawResponse.message));
+            throw new CommandError(rawResponse.message);
         }
         else {
-            callback(new CommandError(rawResponse));
+            throw new CommandError(rawResponse);
         }
     }
-    handleRejectedPromise(rawResponse, logger, callback) {
-        this.handleError(rawResponse, logger, callback);
+    handleRejectedPromise(rawResponse) {
+        this.handleError(rawResponse);
     }
     initAction(args, logger) {
-        this._debug = args.options.debug || process.env.CLIMICROSOFT365_DEBUG === '1';
-        this._verbose = this._debug || args.options.verbose || process.env.CLIMICROSOFT365_VERBOSE === '1';
-        request_1.default.debug = this._debug;
+        this.debug = args.options.debug || process.env.CLIMICROSOFT365_DEBUG === '1';
+        this.verbose = this.debug || args.options.verbose || process.env.CLIMICROSOFT365_VERBOSE === '1';
+        request_1.default.debug = this.debug;
         request_1.default.logger = logger;
         appInsights_1.default.trackEvent({
             name: this.getUsedCommandName(),
@@ -264,7 +316,7 @@ class Command {
         const unknownOptions = JSON.parse(JSON.stringify(options));
         // remove minimist catch-all option
         delete unknownOptions._;
-        const knownOptions = this.options();
+        const knownOptions = this.options;
         const longOptionRegex = /--([^\s]+)/;
         const shortOptionRegex = /-([a-z])\b/;
         knownOptions.forEach(o => {
@@ -314,6 +366,60 @@ class Command {
             }
         });
     }
+    showDeprecationWarning(logger, deprecated, recommended) {
+        const cli = cli_1.Cli.getInstance();
+        if (cli.currentCommandName &&
+            cli.currentCommandName.indexOf(deprecated) === 0) {
+            const chalk = require('chalk');
+            logger.logToStderr(chalk.yellow(`Command '${deprecated}' is deprecated. Please use '${recommended}' instead`));
+        }
+    }
+    warn(logger, warning) {
+        const chalk = require('chalk');
+        logger.logToStderr(chalk.yellow(warning));
+    }
+    getUsedCommandName() {
+        const cli = cli_1.Cli.getInstance();
+        const commandName = this.getCommandName();
+        if (!cli.currentCommandName) {
+            return commandName;
+        }
+        if (cli.currentCommandName &&
+            cli.currentCommandName.indexOf(commandName) === 0) {
+            return commandName;
+        }
+        // since the command was called by something else than its name
+        // it must have aliases
+        const aliases = this.alias();
+        for (let i = 0; i < aliases.length; i++) {
+            if (cli.currentCommandName.indexOf(aliases[i]) === 0) {
+                return aliases[i];
+            }
+        }
+        // shouldn't happen because the command is called either by its name or alias
+        return '';
+    }
+    getTelemetryProperties(args) {
+        this.telemetry.forEach(t => t(args));
+        return this.telemetryProperties;
+    }
 }
 exports.default = Command;
+_Command_instances = new WeakSet(), _Command_initTelemetry = function _Command_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            debug: this.debug.toString(),
+            verbose: this.verbose.toString(),
+            output: args.options.output,
+            query: typeof args.options.query !== 'undefined'
+        });
+    });
+}, _Command_initOptions = function _Command_initOptions() {
+    this.options.unshift({ option: '--query [query]' }, {
+        option: '-o, --output [output]',
+        autocomplete: ['csv', 'json', 'text']
+    }, { option: '--verbose' }, { option: '--debug' });
+}, _Command_initValidators = function _Command_initValidators() {
+    this.validators.push((args, command) => this.validateUnknownOptions(args, command), (args, command) => this.validateRequiredOptions(args, command), (args, command) => this.validateOptionSets(args, command));
+};
 //# sourceMappingURL=Command.js.map