@pnp/cli-microsoft365 7.2.0-beta.54705a9 → 7.2.0-beta.8577f52

package/dist/cli/Cli.js

@@ -1,10 +1,11 @@
 import Configstore from 'configstore';
 import fs from 'fs';
 import minimist from 'minimist';
+import { createRequire } from 'module';
 import ora from 'ora';
 import os from 'os';
 import path from 'path';
-import { pathToFileURL } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 import Command, { CommandError } from '../Command.js';
 import config from '../config.js';
 import request from '../request.js';
@@ -12,10 +13,12 @@ import { settingsNames } from '../settingsNames.js';
 import { telemetry } from '../telemetry.js';
 import { app } from '../utils/app.js';
 import { formatting } from '../utils/formatting.js';
-import { fsUtil } from '../utils/fsUtil.js';
 import { md } from '../utils/md.js';
 import { validation } from '../utils/validation.js';
 import { prompt } from '../utils/prompt.js';
+import { timings } from './timings.js';
+const require = createRequire(import.meta.url);
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
 export class Cli {
     get config() {
         if (!this._config) {
@@ -34,7 +37,6 @@ export class Cli {
     }
     constructor() {
         this.commands = [];
-        this.commandsFolder = '';
         const options = {
             text: 'Running command...',
             /* c8 ignore next 1 */
@@ -48,8 +50,11 @@ export class Cli {
         }
         return Cli.instance;
     }
-    async execute(commandsFolder, rawArgs) {
-        this.commandsFolder = commandsFolder;
+    async execute(rawArgs) {
+        const start = process.hrtime.bigint();
+        // for completion commands we also need information about commands' options
+        const loadAllCommandInfo = rawArgs.indexOf('completion') > -1;
+        this.loadAllCommandsInfo(loadAllCommandInfo);
         // check if help for a specific command has been requested using the
         // 'm365 help xyz' format. If so, remove 'help' from the array of words
         // to use lazy loading commands but keep track of the fact that help should
@@ -59,22 +64,10 @@ export class Cli {
             showHelp = true;
             rawArgs.shift();
         }
-        // parse args to see if a command has been specified and can be loaded
-        // rather than loading all commands
+        // parse args to see if a command has been specified
         const parsedArgs = minimist(rawArgs);
-        // load commands
+        // load command
         await this.loadCommandFromArgs(parsedArgs._);
-        if (this.currentCommandName) {
-            for (let i = 0; i < this.commands.length; i++) {
-                const command = this.commands[i];
-                if (command.name === this.currentCommandName ||
-                    (command.aliases &&
-                        command.aliases.indexOf(this.currentCommandName) > -1)) {
-                    this.commandToExecute = command;
-                    break;
-                }
-            }
-        }
         if (this.commandToExecute) {
             // we have found a command to execute. Parse args again taking into
             // account short and long options, option types and whether the command
@@ -90,6 +83,8 @@ export class Cli {
             }
         }
         else {
+            // we need this to properly support displaying commands
+            // from the current group
             this.optionsFromArgs = {
                 options: parsedArgs
             };
@@ -113,26 +108,56 @@ export class Cli {
         catch (e) {
             return this.closeWithError(e, optionsWithoutShorts);
         }
+        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 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);
         }
         // if output not specified, set the configured output value (if any)
         if (optionsWithoutShorts.options.output === undefined) {
             optionsWithoutShorts.options.output = this.getSettingWithDefaultValue(settingsNames.output, 'json');
         }
+        const startValidation = process.hrtime.bigint();
         const validationResult = await this.commandToExecute.command.validate(optionsWithoutShorts, this.commandToExecute);
+        const endValidation = process.hrtime.bigint();
+        timings.validation.push(Number(endValidation - startValidation));
         if (validationResult !== true) {
             return this.closeWithError(validationResult, optionsWithoutShorts, true);
         }
-        return Cli
-            .executeCommand(this.commandToExecute.command, optionsWithoutShorts)
-            .then(_ => process.exit(0), err => this.closeWithError(err, optionsWithoutShorts));
+        const end = process.hrtime.bigint();
+        timings.core.push(Number(end - start));
+        try {
+            await Cli.executeCommand(this.commandToExecute.command, optionsWithoutShorts);
+            const endTotal = process.hrtime.bigint();
+            timings.total.push(Number(endTotal - start));
+            this.printTimings(rawArgs);
+            process.exit(0);
+        }
+        catch (err) {
+            const endTotal = process.hrtime.bigint();
+            timings.total.push(Number(endTotal - start));
+            this.printTimings(rawArgs);
+            await this.closeWithError(err, optionsWithoutShorts);
+            /* c8 ignore next */
+        }
+    }
+    printTimings(rawArgs) {
+        if (rawArgs.some(arg => arg === '--debug')) {
+            Cli.error('');
+            Cli.error('Timings:');
+            Object.getOwnPropertyNames(timings).forEach(key => {
+                Cli.error(`${key}: ${timings[key].reduce((a, b) => a + b, 0) / 1e6}ms`);
+            });
+        }
     }
     static async executeCommand(command, args) {
         const logger = {
@@ -167,6 +192,7 @@ export class Cli {
         if (showSpinner && typeof global.it === 'undefined') {
             cli.spinner.start();
         }
+        const startCommand = process.hrtime.bigint();
         try {
             await command.action(logger, args);
             if (args.options.debug || args.options.verbose) {
@@ -181,6 +207,8 @@ export class Cli {
             if (cli.spinner.isSpinning) {
                 cli.spinner.stop();
             }
+            const endCommand = process.hrtime.bigint();
+            timings.command.push(Number(endCommand - startCommand));
         }
     }
     static async executeCommandWithOutput(command, args, listener) {
@@ -248,55 +276,26 @@ export class Cli {
             request.logger = currentLogger;
         }
     }
-    async loadAllCommands() {
-        const files = fsUtil.readdirR(this.commandsFolder);
-        await Promise.all(files.map(async (filePath) => {
-            const file = pathToFileURL(filePath).toString();
-            if (file.indexOf(`/commands/`) > -1 &&
-                file.indexOf(`/assets/`) < 0 &&
-                file.endsWith('.js') &&
-                !file.endsWith('.spec.js')) {
-                try {
-                    const command = await import(file);
-                    if (command.default instanceof Command) {
-                        this.loadCommand(command.default);
-                    }
-                }
-                catch (e) {
-                    this.closeWithError(e, { options: {} });
-                }
-            }
-        }));
+    loadAllCommandsInfo(loadFull = false) {
+        const commandsInfoFileName = loadFull ? 'allCommandsFull.json' : 'allCommands.json';
+        this.commands = require(path.join(__dirname, '..', '..', commandsInfoFileName));
     }
     /**
      * Loads command files into CLI based on the specified arguments.
      *
      * @param commandNameWords Array of words specified as args
-     */
+    */
     async loadCommandFromArgs(commandNameWords) {
-        this.currentCommandName = commandNameWords.join(' ');
         if (commandNameWords.length === 0) {
-            await this.loadAllCommands();
-            return;
-        }
-        const isCompletionCommand = commandNameWords.indexOf('completion') > -1;
-        if (isCompletionCommand) {
-            await this.loadAllCommands();
             return;
         }
-        let commandFilePath = '';
-        if (commandNameWords.length === 1) {
-            commandFilePath = path.join(this.commandsFolder, 'commands', `${commandNameWords[0]}.js`);
-        }
-        else {
-            if (commandNameWords.length === 2) {
-                commandFilePath = path.join(this.commandsFolder, commandNameWords[0], 'commands', `${commandNameWords.join('-')}.js`);
-            }
-            else {
-                commandFilePath = path.join(this.commandsFolder, commandNameWords[0], 'commands', commandNameWords[1], commandNameWords.slice(1).join('-') + '.js');
-            }
+        this.currentCommandName = commandNameWords.join(' ');
+        const commandFilePath = this.commands
+            .find(c => c.name === this.currentCommandName ||
+            c.aliases?.find(a => a === this.currentCommandName))?.file ?? '';
+        if (commandFilePath) {
+            await this.loadCommandFromFile(commandFilePath);
         }
-        await this.loadCommandFromFile(commandFilePath);
     }
     async loadOptionsFromContext(commandOptions, debug) {
         const filePath = '.m365rc.json';
@@ -339,39 +338,37 @@ export class Cli {
      * Loads command from the specified file into CLI. If can't find the file
      * or the file doesn't contain a command, loads all available commands.
      *
-     * @param commandFilePath File path of the file with command to load
+     * @param commandFilePathUrl File path of the file with command to load
      */
-    async loadCommandFromFile(commandFilePath) {
-        if (!fs.existsSync(commandFilePath)) {
-            await this.loadAllCommands();
+    async loadCommandFromFile(commandFileUrl) {
+        const commandsFolder = path.join(__dirname, '../m365');
+        const filePath = path.join(commandsFolder, commandFileUrl);
+        if (!fs.existsSync(filePath)) {
+            // reset command name
+            this.currentCommandName = undefined;
             return;
         }
         try {
-            const commandFileUrl = pathToFileURL(commandFilePath).toString();
-            const command = await import(commandFileUrl);
+            const command = await import(pathToFileURL(filePath).toString());
             if (command.default instanceof Command) {
-                this.loadCommand(command.default);
-            }
-            else {
-                await this.loadAllCommands();
+                const commandInfo = this.commands.find(c => c.file === commandFileUrl);
+                this.commandToExecute = Cli.getCommandInfo(command.default, commandFileUrl, commandInfo?.help);
             }
         }
-        catch {
-            await this.loadAllCommands();
-        }
+        catch { }
     }
-    static getCommandInfo(command) {
+    static getCommandInfo(command, filePath = '', helpFilePath = '') {
         return {
             aliases: command.alias(),
             name: command.name,
+            description: command.description,
             command: command,
             options: this.getCommandOptions(command),
-            defaultProperties: command.defaultProperties()
+            defaultProperties: command.defaultProperties(),
+            file: filePath,
+            help: helpFilePath
         };
     }
-    loadCommand(command) {
-        this.commands.push(Cli.getCommandInfo(command));
-    }
     static getCommandOptions(command) {
         const options = [];
         command.options.forEach(option => {
@@ -508,7 +505,7 @@ export class Cli {
         if (arrayType !== 'object') {
             return logStatement.join(os.EOL);
         }
-        // if output type has been set to 'text' or 'csv', process the retrieved
+        // if output type has been set to 'text', process the retrieved
         // data so that returned objects contain only default properties specified
         // on the current command. If there is no current command or the
         // command doesn't specify default properties, return original data
@@ -568,58 +565,39 @@ export class Cli {
         process.exit(exitCode);
     }
     printCommandHelp(helpMode) {
-        let helpFilePath = '';
-        let commandNameWords = [];
-        if (this.commandToExecute) {
-            commandNameWords = (this.commandToExecute.name).split(' ');
-        }
-        const pathChunks = [this.commandsFolder, '..', '..', 'docs', 'docs', 'cmd'];
-        if (commandNameWords.length === 1) {
-            pathChunks.push(`${commandNameWords[0]}.mdx`);
-        }
-        else {
-            if (commandNameWords.length === 2) {
-                pathChunks.push(commandNameWords[0], `${commandNameWords.join('-')}.mdx`);
-            }
-            else {
-                pathChunks.push(commandNameWords[0], commandNameWords[1], commandNameWords.slice(1).join('-') + '.mdx');
-            }
-        }
-        helpFilePath = path.join(...pathChunks);
+        const docsRootDir = path.join(__dirname, '..', '..', 'docs');
+        const helpFilePath = path.join(docsRootDir, 'docs', 'cmd', this.commandToExecute.help);
         if (fs.existsSync(helpFilePath)) {
             let helpContents = fs.readFileSync(helpFilePath, 'utf8');
             helpContents = this.getHelpSection(helpMode, helpContents);
-            helpContents = md.md2plain(helpContents, path.join(this.commandsFolder, '..', '..', 'docs'));
+            helpContents = md.md2plain(helpContents, docsRootDir);
             Cli.log();
             Cli.log(helpContents);
         }
     }
     async getHelpMode(options) {
-        const h = options.h;
-        const help = options.help;
+        const { h, help } = options;
+        if (!h && !help) {
+            return this.getSettingWithDefaultValue(settingsNames.helpMode, Cli.defaultHelpMode);
+        }
         // user passed -h or --help, let's see if they passed a specific mode
         // or requested the default
-        if (h || help) {
-            const helpMode = h ?? help;
-            if (typeof helpMode === 'boolean' || typeof helpMode !== 'string') {
-                // requested default mode or passed a number, let's use default
-                return this.getSettingWithDefaultValue(settingsNames.helpMode, Cli.defaultHelpMode);
+        const helpMode = h ?? help;
+        if (typeof helpMode === 'boolean' || typeof helpMode !== 'string') {
+            // requested default mode or passed a number, let's use default
+            return this.getSettingWithDefaultValue(settingsNames.helpMode, Cli.defaultHelpMode);
+        }
+        else {
+            const lowerCaseHelpMode = helpMode.toLowerCase();
+            if (Cli.helpModes.indexOf(lowerCaseHelpMode) < 0) {
+                await Cli.getInstance().closeWithError(`Unknown help mode ${helpMode}. Allowed values are ${Cli.helpModes.join(', ')}`, { options }, false);
+                /* c8 ignore next 2 */
+                return ''; // noop
             }
             else {
-                const lowerCaseHelpMode = helpMode.toLowerCase();
-                if (Cli.helpModes.indexOf(lowerCaseHelpMode) < 0) {
-                    await Cli.getInstance().closeWithError(`Unknown help mode ${helpMode}. Allowed values are ${Cli.helpModes.join(', ')}`, { options }, false);
-                    /* c8 ignore next 2 */
-                    return ''; // noop
-                }
-                else {
-                    return lowerCaseHelpMode;
-                }
+                return lowerCaseHelpMode;
             }
         }
-        else {
-            return this.getSettingWithDefaultValue(settingsNames.helpMode, Cli.defaultHelpMode);
-        }
     }
     getHelpSection(helpMode, helpContents) {
         if (helpMode === 'full') {
@@ -707,9 +685,10 @@ export class Cli {
             const maxLength = Math.max(...namesOfCommandsToPrint.map(s => s.length)) + 10;
             Cli.log(`Commands:`);
             Cli.log();
-            for (const commandName in commandsToPrint) {
-                Cli.log(`  ${`${commandName} [options]`.padEnd(maxLength, ' ')}  ${commandsToPrint[commandName].command.description}`);
-            }
+            const sortedCommandNamesToPrint = Object.getOwnPropertyNames(commandsToPrint).sort();
+            sortedCommandNamesToPrint.forEach(commandName => {
+                Cli.log(`  ${`${commandName} [options]`.padEnd(maxLength, ' ')}  ${commandsToPrint[commandName].description}`);
+            });
         }
         const namesOfCommandGroupsToPrint = Object.keys(commandGroupsToPrint);
         if (namesOfCommandGroupsToPrint.length > 0) {
@@ -803,35 +782,47 @@ export class Cli {
             cli.spinner.start();
         }
     }
-    static async prompt(options, answers) {
+    static async promptForSelection(config) {
+        const cli = Cli.getInstance();
+        const spinnerSpinning = cli.spinner.isSpinning;
+        /* c8 ignore next 3 */
+        if (spinnerSpinning) {
+            cli.spinner.stop();
+        }
+        const answer = await prompt.forSelection(config);
+        Cli.error('');
+        // Restart the spinner if it was running before the prompt
+        /* c8 ignore next 3 */
+        if (spinnerSpinning) {
+            cli.spinner.start();
+        }
+        return answer;
+    }
+    static async promptForConfirmation(config) {
         const cli = Cli.getInstance();
         const spinnerSpinning = cli.spinner.isSpinning;
         /* c8 ignore next 3 */
         if (spinnerSpinning) {
             cli.spinner.stop();
         }
-        const response = await prompt.forInput(options, answers);
+        const answer = await prompt.forConfirmation(config);
+        Cli.error('');
         // Restart the spinner if it was running before the prompt
         /* c8 ignore next 3 */
         if (spinnerSpinning) {
             cli.spinner.start();
         }
-        return response;
+        return answer;
     }
     static async handleMultipleResultsFound(message, values) {
         const prompt = Cli.getInstance().getSettingWithDefaultValue(settingsNames.prompt, true);
         if (!prompt) {
             throw new Error(`${message} Found: ${Object.keys(values).join(', ')}.`);
         }
-        const response = await Cli.prompt({
-            type: 'list',
-            name: 'select',
-            default: 0,
-            prefix: '🌶️  ',
-            message: `${message} Please choose one:`,
-            choices: Object.keys(values)
-        });
-        return values[response.select];
+        Cli.error(`🌶️  ${message}`);
+        const choices = Object.keys(values).map((choice) => { return { name: choice, value: choice }; });
+        const response = await Cli.promptForSelection({ message: `Please choose one:`, choices });
+        return values[response];
     }
     static removeShortOptions(args) {
         const filteredArgs = JSON.parse(JSON.stringify(args));

package/dist/cli/timings.js

@@ -0,0 +1,9 @@
+export const timings = {
+    api: [],
+    core: [],
+    command: [],
+    options: [],
+    total: [],
+    validation: []
+};
+//# sourceMappingURL=timings.js.map

package/dist/index.js

@@ -1,11 +1,7 @@
 #!/usr/bin/env node
-import fs from 'fs';
-import path from 'path';
-import url from 'url';
 import { Cli } from './cli/Cli.js';
 import { telemetry } from './telemetry.js';
 import { app } from './utils/app.js';
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
 // required to make console.log() in combination with piped output synchronous
 // on Windows/in PowerShell so that the output is not trimmed by calling
 // process.exit() after executing the command, while the output is still
@@ -18,14 +14,12 @@ if (!process.env.CLIMICROSOFT365_NOUPDATE) {
         updateNotifier.default({ pkg: app.packageJson() }).notify({ defer: false });
     });
 }
-fs.realpath(__dirname, async (err, resolvedPath) => {
-    try {
-        const cli = Cli.getInstance();
-        await cli.execute(path.join(resolvedPath, 'm365'), process.argv.slice(2));
-    }
-    catch (e) {
-        telemetry.trackException(e);
-        process.exit(1);
-    }
-});
+try {
+    const cli = Cli.getInstance();
+    cli.execute(process.argv.slice(2));
+}
+catch (e) {
+    telemetry.trackException(e);
+    process.exit(1);
+}
 //# sourceMappingURL=index.js.map

package/dist/m365/aad/commands/administrativeunit/administrativeunit-add.js

@@ -0,0 +1,61 @@
+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 _AadAdministrativeUnitAddCommand_instances, _AadAdministrativeUnitAddCommand_initTelemetry, _AadAdministrativeUnitAddCommand_initOptions;
+import request from "../../../../request.js";
+import GraphCommand from "../../../base/GraphCommand.js";
+import commands from "../../commands.js";
+class AadAdministrativeUnitAddCommand extends GraphCommand {
+    get name() {
+        return commands.ADMINISTRATIVEUNIT_ADD;
+    }
+    get description() {
+        return 'Creates an administrative unit';
+    }
+    constructor() {
+        super();
+        _AadAdministrativeUnitAddCommand_instances.add(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitAddCommand_instances, "m", _AadAdministrativeUnitAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitAddCommand_instances, "m", _AadAdministrativeUnitAddCommand_initOptions).call(this);
+    }
+    async commandAction(logger, args) {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/directory/administrativeUnits`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json',
+            data: {
+                description: args.options.description,
+                displayName: args.options.displayName,
+                visibility: args.options.hiddenMembership ? 'HiddenMembership' : null
+            }
+        };
+        try {
+            const administrativeUnit = await request.post(requestOptions);
+            await logger.log(administrativeUnit);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+_AadAdministrativeUnitAddCommand_instances = new WeakSet(), _AadAdministrativeUnitAddCommand_initTelemetry = function _AadAdministrativeUnitAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            hiddenMembership: !!args.options.hiddenMembership
+        });
+    });
+}, _AadAdministrativeUnitAddCommand_initOptions = function _AadAdministrativeUnitAddCommand_initOptions() {
+    this.options.unshift({
+        option: '-n, --displayName <displayName>'
+    }, {
+        option: '-d, --description [description]'
+    }, {
+        option: '--hiddenMembership'
+    });
+};
+export default new AadAdministrativeUnitAddCommand();
+//# sourceMappingURL=administrativeunit-add.js.map

package/dist/m365/aad/commands/administrativeunit/administrativeunit-get.js

@@ -0,0 +1,80 @@
+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 _AadAdministrativeUnitGetCommand_instances, _AadAdministrativeUnitGetCommand_initTelemetry, _AadAdministrativeUnitGetCommand_initOptions, _AadAdministrativeUnitGetCommand_initValidators, _AadAdministrativeUnitGetCommand_initOptionSets, _AadAdministrativeUnitGetCommand_initTypes;
+import { validation } from "../../../../utils/validation.js";
+import request from "../../../../request.js";
+import GraphCommand from "../../../base/GraphCommand.js";
+import commands from "../../commands.js";
+import { aadAdministrativeUnit } from "../../../../utils/aadAdministrativeUnit.js";
+class AadAdministrativeUnitGetCommand extends GraphCommand {
+    get name() {
+        return commands.ADMINISTRATIVEUNIT_GET;
+    }
+    get description() {
+        return 'Gets information about a specific administrative unit';
+    }
+    constructor() {
+        super();
+        _AadAdministrativeUnitGetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitGetCommand_instances, "m", _AadAdministrativeUnitGetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitGetCommand_instances, "m", _AadAdministrativeUnitGetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitGetCommand_instances, "m", _AadAdministrativeUnitGetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitGetCommand_instances, "m", _AadAdministrativeUnitGetCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitGetCommand_instances, "m", _AadAdministrativeUnitGetCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        let administrativeUnit;
+        try {
+            if (args.options.id) {
+                administrativeUnit = await this.getAdministrativeUnitById(args.options.id);
+            }
+            else {
+                administrativeUnit = await aadAdministrativeUnit.getAdministrativeUnitByDisplayName(args.options.displayName);
+            }
+            await logger.log(administrativeUnit);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getAdministrativeUnitById(id) {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/directory/administrativeUnits/${id}`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        return await request.get(requestOptions);
+    }
+}
+_AadAdministrativeUnitGetCommand_instances = new WeakSet(), _AadAdministrativeUnitGetCommand_initTelemetry = function _AadAdministrativeUnitGetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            id: typeof args.options.id !== 'undefined',
+            displayName: typeof args.options.displayName !== 'undefined'
+        });
+    });
+}, _AadAdministrativeUnitGetCommand_initOptions = function _AadAdministrativeUnitGetCommand_initOptions() {
+    this.options.unshift({
+        option: '-i, --id [id]'
+    }, {
+        option: '-n, --displayName [displayName]'
+    });
+}, _AadAdministrativeUnitGetCommand_initValidators = function _AadAdministrativeUnitGetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.id && !validation.isValidGuid(args.options.id)) {
+            return `${args.options.id} is not a valid GUID`;
+        }
+        return true;
+    });
+}, _AadAdministrativeUnitGetCommand_initOptionSets = function _AadAdministrativeUnitGetCommand_initOptionSets() {
+    this.optionSets.push({ options: ['id', 'displayName'] });
+}, _AadAdministrativeUnitGetCommand_initTypes = function _AadAdministrativeUnitGetCommand_initTypes() {
+    this.types.string.push('displayName');
+};
+export default new AadAdministrativeUnitGetCommand();
+//# sourceMappingURL=administrativeunit-get.js.map

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

@@ -0,0 +1,25 @@
+import { odata } from '../../../../utils/odata.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class AadAdministrativeUnitListCommand extends GraphCommand {
+    get name() {
+        return commands.ADMINISTRATIVEUNIT_LIST;
+    }
+    get description() {
+        return 'Retrieves a list of administrative units';
+    }
+    defaultProperties() {
+        return ['id', 'displayName', 'visibility'];
+    }
+    async commandAction(logger) {
+        try {
+            const results = await odata.getAllItems(`${this.resource}/v1.0/directory/administrativeUnits`);
+            await logger.log(results);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new AadAdministrativeUnitListCommand();
+//# sourceMappingURL=administrativeunit-list.js.map