@pnp/cli-microsoft365 7.11.0-beta.c513557 → 8.0.0-beta.3c404b8

package/dist/m365/spfx/commands/project/base-project-command.js

@@ -4,6 +4,7 @@ import { formatting } from '../../../../utils/formatting.js';
 import { fsUtil } from '../../../../utils/fsUtil.js';
 import AnonymousCommand from "../../../base/AnonymousCommand.js";
 import { ScssFile, TsFile } from "./project-model/index.js";
+import { CommandError } from '../../../../Command.js';
 export class BaseProjectCommand extends AnonymousCommand {
     constructor() {
         super(...arguments);
@@ -31,105 +32,17 @@ export class BaseProjectCommand extends AnonymousCommand {
             }
             catch { }
         }
-        const configJsonPath = path.join(projectRootPath, 'config/config.json');
-        if (fs.existsSync(configJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(configJsonPath, 'utf-8'));
-                project.configJson = JSON.parse(source);
-                project.configJson.source = source;
-            }
-            catch { }
-        }
-        const copyAssetsJsonPath = path.join(projectRootPath, 'config/copy-assets.json');
-        if (fs.existsSync(copyAssetsJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(copyAssetsJsonPath, 'utf-8'));
-                project.copyAssetsJson = JSON.parse(source);
-                project.copyAssetsJson.source = source;
-            }
-            catch { }
-        }
-        const deployAzureStorageJsonPath = path.join(projectRootPath, 'config/deploy-azure-storage.json');
-        if (fs.existsSync(deployAzureStorageJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(deployAzureStorageJsonPath, 'utf-8'));
-                project.deployAzureStorageJson = JSON.parse(source);
-                project.deployAzureStorageJson.source = source;
-            }
-            catch { }
-        }
-        const packageJsonPath = path.join(projectRootPath, 'package.json');
-        if (fs.existsSync(packageJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(packageJsonPath, 'utf-8'));
-                project.packageJson = JSON.parse(source);
-                project.packageJson.source = source;
-            }
-            catch { }
-        }
-        const packageSolutionJsonPath = path.join(projectRootPath, 'config/package-solution.json');
-        if (fs.existsSync(packageSolutionJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(packageSolutionJsonPath, 'utf-8'));
-                project.packageSolutionJson = JSON.parse(source);
-                project.packageSolutionJson.source = source;
-            }
-            catch { }
-        }
-        const serveJsonPath = path.join(projectRootPath, 'config/serve.json');
-        if (fs.existsSync(serveJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(serveJsonPath, 'utf-8'));
-                project.serveJson = JSON.parse(source);
-                project.serveJson.source = source;
-            }
-            catch { }
-        }
-        const tsConfigJsonPath = path.join(projectRootPath, 'tsconfig.json');
-        if (fs.existsSync(tsConfigJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(tsConfigJsonPath, 'utf-8'));
-                project.tsConfigJson = JSON.parse(source);
-                project.tsConfigJson.source = source;
-            }
-            catch { }
-        }
-        const tsLintJsonPath = path.join(projectRootPath, 'config/tslint.json');
-        if (fs.existsSync(tsLintJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(tsLintJsonPath, 'utf-8'));
-                project.tsLintJson = JSON.parse(source);
-                project.tsLintJson.source = source;
-            }
-            catch { }
-        }
-        const tsLintJsonRootPath = path.join(projectRootPath, 'tslint.json');
-        if (fs.existsSync(tsLintJsonRootPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(tsLintJsonRootPath, 'utf-8'));
-                project.tsLintJsonRoot = JSON.parse(source);
-                project.tsLintJsonRoot.source = source;
-            }
-            catch { }
-        }
-        const writeManifestJsonPath = path.join(projectRootPath, 'config/write-manifests.json');
-        if (fs.existsSync(writeManifestJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(writeManifestJsonPath, 'utf-8'));
-                project.writeManifestsJson = JSON.parse(source);
-                project.writeManifestsJson.source = source;
-            }
-            catch { }
-        }
-        const yoRcJsonPath = path.join(projectRootPath, '.yo-rc.json');
-        if (fs.existsSync(yoRcJsonPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(yoRcJsonPath, 'utf-8'));
-                project.yoRcJson = JSON.parse(source);
-                project.yoRcJson.source = source;
-            }
-            catch { }
-        }
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'config.json'), project, 'configJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'copy-assets.json'), project, 'copyAssetsJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'deploy-azure-storage.json'), project, 'deployAzureStorageJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'package.json'), project, 'packageJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'package-solution.json'), project, 'packageSolutionJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'serve.json'), project, 'serveJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'tsconfig.json'), project, 'tsConfigJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'tslint.json'), project, 'tsLintJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'tslint.json'), project, 'tsLintJsonRoot');
+        this.readAndParseJsonFile(path.join(projectRootPath, 'config', 'write-manifests.json'), project, 'writeManifestsJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, '.yo-rc.json'), project, 'yoRcJson');
         const gulpfileJsPath = path.join(projectRootPath, 'gulpfile.js');
         if (fs.existsSync(gulpfileJsPath)) {
             project.gulpfileJs = {
@@ -141,33 +54,9 @@ export class BaseProjectCommand extends AnonymousCommand {
             project.esLintRcJs = new TsFile(esLintRcJsPath);
         }
         project.vsCode = {};
-        const vsCodeSettingsPath = path.join(projectRootPath, '.vscode', 'settings.json');
-        if (fs.existsSync(vsCodeSettingsPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(vsCodeSettingsPath, 'utf-8'));
-                project.vsCode.settingsJson = JSON.parse(source);
-                project.vsCode.settingsJson.source = source;
-            }
-            catch { }
-        }
-        const vsCodeExtensionsPath = path.join(projectRootPath, '.vscode', 'extensions.json');
-        if (fs.existsSync(vsCodeExtensionsPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(vsCodeExtensionsPath, 'utf-8'));
-                project.vsCode.extensionsJson = JSON.parse(source);
-                project.vsCode.extensionsJson.source = source;
-            }
-            catch { }
-        }
-        const vsCodeLaunchPath = path.join(projectRootPath, '.vscode', 'launch.json');
-        if (fs.existsSync(vsCodeLaunchPath)) {
-            try {
-                const source = formatting.removeSingleLineComments(fs.readFileSync(vsCodeLaunchPath, 'utf-8'));
-                project.vsCode.launchJson = JSON.parse(source);
-                project.vsCode.launchJson.source = source;
-            }
-            catch { }
-        }
+        this.readAndParseJsonFile(path.join(projectRootPath, '.vscode', 'settings.json'), project, 'vsCode.settingsJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, '.vscode', 'extensions.json'), project, 'vsCode.extensionsJson');
+        this.readAndParseJsonFile(path.join(projectRootPath, '.vscode', 'launch.json'), project, 'vsCode.launchJson');
         const srcFiles = fsUtil.readdirR(path.join(projectRootPath, 'src'));
         const manifestFiles = srcFiles.filter(f => f.endsWith('.manifest.json'));
         const manifests = manifestFiles.map((f) => {
@@ -233,5 +122,26 @@ export class BaseProjectCommand extends AnonymousCommand {
         catch { }
         return undefined;
     }
+    readAndParseJsonFile(filePath, project, keyPath) {
+        if (fs.existsSync(filePath)) {
+            try {
+                const source = formatting.removeSingleLineComments(fs.readFileSync(filePath, 'utf-8'));
+                const keys = keyPath.split('.');
+                let current = project;
+                for (let i = 0; i < keys.length - 1; i++) {
+                    current = current[keys[i]];
+                }
+                const finalKey = keys[keys.length - 1];
+                current[finalKey] = JSON.parse(source);
+                if (typeof current[finalKey] === 'object' && current[finalKey] !== null) {
+                    current[finalKey].source = source;
+                }
+            }
+            catch (error) {
+                throw new CommandError(`The file ${filePath} is not a valid JSON file or is not utf-8 encoded. Error: ${error}`);
+            }
+        }
+        return project;
+    }
 }
 //# sourceMappingURL=base-project-command.js.map

package/dist/m365/spfx/commands/project/project-azuredevops-pipeline-add.js

@@ -37,7 +37,7 @@ class SpfxProjectAzureDevOpsPipelineAddCommand extends BaseProjectCommand {
         const packageJson = fs.readFileSync(solutionPackageJsonFile, 'utf-8');
         const solutionName = JSON.parse(packageJson).name;
         if (this.debug) {
-            logger.logToStderr(`Adding Azure DevOps pipeline in the current SPFx project`);
+            await logger.logToStderr(`Adding Azure DevOps pipeline in the current SPFx project`);
         }
         try {
             this.updatePipeline(solutionName, pipeline, args.options);

package/dist/m365/spfx/commands/project/project-externalize.js

@@ -81,7 +81,7 @@ class SpfxProjectExternalizeCommand extends BaseProjectCommand {
             this.allEditSuggestions.push(...rulesResults.map(x => x.suggestions).reduce((x, y) => [...x, ...y]));
             //removing duplicates
             this.allFindings = this.allFindings.filter((x, i) => this.allFindings.findIndex(y => y.key === x.key) === i);
-            this.writeReport(this.allFindings, this.allEditSuggestions, logger, args.options);
+            await this.writeReport(this.allFindings, this.allEditSuggestions, logger, args.options);
         }
         catch (err) {
             throw new CommandError(err);

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

@@ -40,7 +40,7 @@ class SpfxProjectGithubWorkflowAddCommand extends BaseProjectCommand {
         const packageJson = fs.readFileSync(solutionPackageJsonFile, 'utf-8');
         const solutionName = JSON.parse(packageJson).name;
         if (this.debug) {
-            logger.logToStderr(`Adding GitHub workflow in the current SPFx project`);
+            await logger.logToStderr(`Adding GitHub workflow in the current SPFx project`);
         }
         try {
             this.updateWorkflow(solutionName, workflow, args.options);

package/dist/m365/spfx/commands/spfx-doctor.js

@@ -713,7 +713,7 @@ class SpfxDoctorCommand extends BaseProjectCommand {
     }
     async checkNodeVersion(prerequisites) {
         const nodeVersion = this.getNodeVersion();
-        this.checkStatus('Node', nodeVersion, prerequisites.node);
+        await this.checkStatus('Node', nodeVersion, prerequisites.node);
     }
     async checkSharePointFrameworkVersion(spfxVersionRequested) {
         let spfxVersionDetected = await this.getSPFxVersionFromYoRcFile();
@@ -725,7 +725,7 @@ class SpfxDoctorCommand extends BaseProjectCommand {
             fix: `npm i -g @microsoft/generator-sharepoint@${spfxVersionRequested}`
         };
         if (spfxVersionDetected) {
-            this.checkStatus(`SharePoint Framework`, spfxVersionDetected, versionCheck);
+            await this.checkStatus(`SharePoint Framework`, spfxVersionDetected, versionCheck);
         }
         else {
             const message = `SharePoint Framework v${spfxVersionRequested} not found`;
@@ -742,7 +742,7 @@ class SpfxDoctorCommand extends BaseProjectCommand {
     async checkYo(prerequisites) {
         const yoVersion = await this.getPackageVersion('yo', PackageSearchMode.GlobalOnly, HandlePromise.Continue);
         if (yoVersion) {
-            this.checkStatus('yo', yoVersion, prerequisites.yo);
+            await this.checkStatus('yo', yoVersion, prerequisites.yo);
         }
         else {
             const message = 'yo not found';
@@ -758,7 +758,7 @@ class SpfxDoctorCommand extends BaseProjectCommand {
     async checkGulpCli(prerequisites) {
         const gulpCliVersion = await this.getPackageVersion('gulp-cli', PackageSearchMode.GlobalOnly, HandlePromise.Continue);
         if (gulpCliVersion) {
-            this.checkStatus('gulp-cli', gulpCliVersion, prerequisites.gulpCli);
+            await this.checkStatus('gulp-cli', gulpCliVersion, prerequisites.gulpCli);
         }
         else {
             const message = 'gulp-cli not found';

package/dist/m365/spo/commands/cdn/cdn-get.js

@@ -3,7 +3,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _SpoCdnGetCommand_instances, _SpoCdnGetCommand_initTelemetry, _SpoCdnGetCommand_initOptions, _SpoCdnGetCommand_initValidators;
+var _SpoCdnGetCommand_instances, _SpoCdnGetCommand_initTelemetry, _SpoCdnGetCommand_initOptions, _SpoCdnGetCommand_initValidators, _SpoCdnGetCommand_initTypes;
 import config from '../../../../config.js';
 import request from '../../../../request.js';
 import { spo } from '../../../../utils/spo.js';
@@ -19,9 +19,11 @@ class SpoCdnGetCommand extends SpoCommand {
     constructor() {
         super();
         _SpoCdnGetCommand_instances.add(this);
+        this.validTypes = ['Public', 'Private'];
         __classPrivateFieldGet(this, _SpoCdnGetCommand_instances, "m", _SpoCdnGetCommand_initTelemetry).call(this);
         __classPrivateFieldGet(this, _SpoCdnGetCommand_instances, "m", _SpoCdnGetCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoCdnGetCommand_instances, "m", _SpoCdnGetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoCdnGetCommand_instances, "m", _SpoCdnGetCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
         const cdnTypeString = args.options.type || 'Public';
@@ -48,15 +50,11 @@ class SpoCdnGetCommand extends SpoCommand {
             if (response.ErrorInfo) {
                 throw response.ErrorInfo.ErrorMessage;
             }
-            else {
-                const result = json[json.length - 1];
-                if (this.verbose) {
-                    await logger.logToStderr(`${(cdnType === 0 ? 'Public' : 'Private')} CDN at ${spoAdminUrl} is ${(result === true ? 'enabled' : 'disabled')}`);
-                }
-                else {
-                    await logger.logToStderr(result);
-                }
+            const result = json[json.length - 1];
+            if (this.verbose) {
+                await logger.logToStderr(`${cdnType === 0 ? 'Public' : 'Private'} CDN at ${spoAdminUrl} is ${result === true ? 'enabled' : 'disabled'}`);
             }
+            await logger.log(result);
         }
         catch (err) {
             this.handleRejectedPromise(err);
@@ -72,18 +70,17 @@ _SpoCdnGetCommand_instances = new WeakSet(), _SpoCdnGetCommand_initTelemetry = f
 }, _SpoCdnGetCommand_initOptions = function _SpoCdnGetCommand_initOptions() {
     this.options.unshift({
         option: '-t, --type [type]',
-        autocomplete: ['Public', 'Private']
+        autocomplete: this.validTypes
     });
 }, _SpoCdnGetCommand_initValidators = function _SpoCdnGetCommand_initValidators() {
     this.validators.push(async (args) => {
-        if (args.options.type) {
-            if (args.options.type !== 'Public' &&
-                args.options.type !== 'Private') {
-                return `${args.options.type} is not a valid CDN type. Allowed values are Public|Private`;
-            }
+        if (args.options.type && !this.validTypes.includes(args.options.type)) {
+            return `'${args.options.type}' is not a valid CDN type. Allowed values are: ${this.validTypes.join(', ')}.`;
         }
         return true;
     });
+}, _SpoCdnGetCommand_initTypes = function _SpoCdnGetCommand_initTypes() {
+    this.types.string.push('type');
 };
 export default new SpoCdnGetCommand();
 //# sourceMappingURL=cdn-get.js.map

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

@@ -19,6 +19,7 @@ class SpoCdnSetCommand extends SpoCommand {
     constructor() {
         super();
         _SpoCdnSetCommand_instances.add(this);
+        this.validTypes = ['Public', 'Private', 'Both'];
         __classPrivateFieldGet(this, _SpoCdnSetCommand_instances, "m", _SpoCdnSetCommand_initTelemetry).call(this);
         __classPrivateFieldGet(this, _SpoCdnSetCommand_instances, "m", _SpoCdnSetCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoCdnSetCommand_instances, "m", _SpoCdnSetCommand_initTypes).call(this);
@@ -104,7 +105,7 @@ _SpoCdnSetCommand_instances = new WeakSet(), _SpoCdnSetCommand_initTelemetry = f
         Object.assign(this.telemetryProperties, {
             cdnType: args.options.type || 'Public',
             enabled: args.options.enabled,
-            noDefaultOrigins: (!(!args.options.noDefaultOrigins)).toString()
+            noDefaultOrigins: !!args.options.noDefaultOrigins
         });
     });
 }, _SpoCdnSetCommand_initOptions = function _SpoCdnSetCommand_initOptions() {
@@ -113,18 +114,19 @@ _SpoCdnSetCommand_instances = new WeakSet(), _SpoCdnSetCommand_initTelemetry = f
         autocomplete: ['true', 'false']
     }, {
         option: '-t, --type [type]',
-        autocomplete: ['Public', 'Private', 'Both']
+        autocomplete: this.validTypes
     }, {
         option: '--noDefaultOrigins'
     });
 }, _SpoCdnSetCommand_initTypes = function _SpoCdnSetCommand_initTypes() {
-    this.types.boolean.push('enabled');
+    this.types.boolean.push('enabled', 'noDefaultOrigins');
+    this.types.string.push('type');
 }, _SpoCdnSetCommand_initValidators = function _SpoCdnSetCommand_initValidators() {
     this.validators.push(async (args) => {
         if (args.options.type) {
             if (args.options.type !== 'Public' && args.options.type !== 'Both' &&
                 args.options.type !== 'Private') {
-                return `${args.options.type} is not a valid CDN type. Allowed values are Public|Private|Both`;
+                return `${args.options.type} is not a valid CDN type. Allowed values are ${this.validTypes.join(', ')}.`;
             }
         }
         return true;

package/dist/m365/spo/commands/commandset/commandset-get.js

@@ -60,7 +60,7 @@ class SpoCommandSetGetCommand extends SpoCommand {
                 else {
                     const resultAsKeyValuePair = formatting.convertArrayToHashTable('Id', commandSets);
                     const commandSet = await cli.handleMultipleResultsFound(`Multiple command sets with title '${args.options.title}' found.`, resultAsKeyValuePair);
-                    logger.log(commandSet);
+                    await logger.log(commandSet);
                 }
             }
         }

package/dist/m365/spo/commands/contenttype/contenttype-field-list.js

@@ -0,0 +1,124 @@
+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 _SpoContentTypeFieldListCommand_instances, _SpoContentTypeFieldListCommand_initTelemetry, _SpoContentTypeFieldListCommand_initOptions, _SpoContentTypeFieldListCommand_initValidators, _SpoContentTypeFieldListCommand_initTypes, _SpoContentTypeFieldListCommand_initOptionSets;
+import { formatting } from '../../../../utils/formatting.js';
+import { odata } from '../../../../utils/odata.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+class SpoContentTypeFieldListCommand extends SpoCommand {
+    get name() {
+        return commands.CONTENTTYPE_FIELD_LIST;
+    }
+    get description() {
+        return 'Lists fields for a given site or list content type';
+    }
+    defaultProperties() {
+        return ['Id', 'Title', 'InternalName', 'Hidden'];
+    }
+    constructor() {
+        super();
+        _SpoContentTypeFieldListCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoContentTypeFieldListCommand_instances, "m", _SpoContentTypeFieldListCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpoContentTypeFieldListCommand_instances, "m", _SpoContentTypeFieldListCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpoContentTypeFieldListCommand_instances, "m", _SpoContentTypeFieldListCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpoContentTypeFieldListCommand_instances, "m", _SpoContentTypeFieldListCommand_initTypes).call(this);
+        __classPrivateFieldGet(this, _SpoContentTypeFieldListCommand_instances, "m", _SpoContentTypeFieldListCommand_initOptionSets).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            if (this.verbose) {
+                await logger.logToStderr(`Retrieving fields for content type '${args.options.contentTypeId || args.options.contentTypeName}' in site ${args.options.webUrl}...`);
+            }
+            let requestUrl = `${args.options.webUrl}/_api/web`;
+            if (args.options.listId) {
+                requestUrl += `/lists(guid'${formatting.encodeQueryParameter(args.options.listId)}')`;
+            }
+            else if (args.options.listTitle) {
+                requestUrl += `/lists/getByTitle('${formatting.encodeQueryParameter(args.options.listTitle)}')`;
+            }
+            else if (args.options.listUrl) {
+                const listServerRelativeUrl = urlUtil.getServerRelativePath(args.options.webUrl, args.options.listUrl);
+                requestUrl += `/GetList('${formatting.encodeQueryParameter(listServerRelativeUrl)}')`;
+            }
+            requestUrl += '/contentTypes';
+            const contentTypeId = await this.getContentTypeId(requestUrl, logger, args.options.contentTypeId, args.options.contentTypeName);
+            requestUrl += `('${formatting.encodeQueryParameter(contentTypeId)}')/fields`;
+            if (args.options.properties) {
+                requestUrl += `?$select=${args.options.properties}`;
+            }
+            const res = await odata.getAllItems(requestUrl);
+            await logger.log(res);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getContentTypeId(requestUrl, logger, contentTypeId, contentTypeName) {
+        if (contentTypeId) {
+            return contentTypeId;
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Retrieving content type id for content type '${contentTypeName}'.`);
+        }
+        const res = await odata.getAllItems(`${requestUrl}?$filter=Name eq '${formatting.encodeQueryParameter(contentTypeName)}'&$select=StringId`);
+        if (res.length === 0) {
+            throw `Content type with name ${contentTypeName} not found.`;
+        }
+        return res[0].StringId;
+    }
+}
+_SpoContentTypeFieldListCommand_instances = new WeakSet(), _SpoContentTypeFieldListCommand_initTelemetry = function _SpoContentTypeFieldListCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            contentTypeId: typeof args.options.contentTypeId !== 'undefined',
+            contentTypeName: typeof args.options.contentTypeName !== 'undefined',
+            listId: typeof args.options.listId !== 'undefined',
+            listTitle: typeof args.options.listTitle !== 'undefined',
+            listUrl: typeof args.options.listUrl !== 'undefined',
+            properties: typeof args.options.properties !== 'undefined'
+        });
+    });
+}, _SpoContentTypeFieldListCommand_initOptions = function _SpoContentTypeFieldListCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --webUrl <webUrl>'
+    }, {
+        option: '-i, --contentTypeId [contentTypeId]'
+    }, {
+        option: '-n, --contentTypeName [contentTypeName]'
+    }, {
+        option: '-l, --listTitle [listTitle]'
+    }, {
+        option: '--listId [listId]'
+    }, {
+        option: '--listUrl [listUrl]'
+    }, {
+        option: '-p, --properties [properties]'
+    });
+}, _SpoContentTypeFieldListCommand_initValidators = function _SpoContentTypeFieldListCommand_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} is not a valid GUID for option 'listId'.`;
+        }
+        return true;
+    });
+}, _SpoContentTypeFieldListCommand_initTypes = function _SpoContentTypeFieldListCommand_initTypes() {
+    this.types.string.push('webUrl', 'contentTypeId', 'contentTypeName', 'listTitle', 'listId', 'listUrl', 'properties');
+}, _SpoContentTypeFieldListCommand_initOptionSets = function _SpoContentTypeFieldListCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['contentTypeId', 'contentTypeName']
+    }, {
+        options: ['listId', 'listTitle', 'listUrl'],
+        runsWhen: (args) => args.options.listId || args.options.listTitle || args.options.listUrl
+    });
+};
+export default new SpoContentTypeFieldListCommand();
+//# sourceMappingURL=contenttype-field-list.js.map

package/dist/m365/spo/commands/field/field-list.js

@@ -18,7 +18,7 @@ class SpoFieldListCommand extends SpoCommand {
         return 'Retrieves columns for the specified list or site';
     }
     defaultProperties() {
-        return ['Id', 'Title', 'Group', 'Hidden'];
+        return ['Id', 'Title', 'InternalName', 'Hidden'];
     }
     constructor() {
         super();

package/dist/m365/spo/commands/file/file-retentionlabel-remove.js

@@ -54,7 +54,7 @@ class SpoFileRetentionLabelRemoveCommand extends SpoCommand {
     }
     async getFileProperties(logger, args) {
         if (this.verbose) {
-            logger.logToStderr(`Retrieving list and item information for file '${args.options.fileId || args.options.fileUrl}' in site at ${args.options.webUrl}...`);
+            await logger.logToStderr(`Retrieving list and item information for file '${args.options.fileId || args.options.fileUrl}' in site at ${args.options.webUrl}...`);
         }
         let requestUrl = `${args.options.webUrl}/_api/web/`;
         if (args.options.fileId) {