@pnp/cli-microsoft365 10.4.0 → 10.5.0-beta.31bfdff

package/dist/m365/graph/commands/directoryextension/directoryextension-add.js

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { globalOptionsZod } from '../../../../Command.js';
+import request from '../../../../request.js';
+import { zod } from '../../../../utils/zod.js';
+import commands from '../../commands.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import { validation } from '../../../../utils/validation.js';
+import { entraApp } from '../../../../utils/entraApp.js';
+const options = globalOptionsZod
+    .extend({
+    name: zod.alias('n', z.string()),
+    appId: z.string().optional(),
+    appObjectId: z.string().optional(),
+    appName: z.string().optional(),
+    dataType: z.enum(['Binary', 'Boolean', 'DateTime', 'Integer', 'LargeInteger', 'String']),
+    targetObjects: z.string().transform((value) => value.split(',').map(String))
+        .pipe(z.enum(['User', 'Group', 'Application', 'AdministrativeUnit', 'Device', 'Organization']).array()),
+    isMultiValued: z.boolean().optional()
+})
+    .strict();
+class GraphDirectoryExtensionAddCommand extends GraphCommand {
+    get name() {
+        return commands.DIRECTORYEXTENSION_ADD;
+    }
+    get description() {
+        return 'Creates a new directory extension';
+    }
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(options => Object.values([options.appId, options.appObjectId, options.appName]).filter(v => typeof v !== 'undefined').length === 1, {
+            message: 'Specify either appId, appObjectId or appName, but not multiple'
+        })
+            .refine(options => (!options.appId && !options.appObjectId && !options.appName) || options.appObjectId || options.appName ||
+            (options.appId && validation.isValidGuid(options.appId)), options => ({
+            message: `The '${options.appId}' must be a valid GUID`,
+            path: ['appId']
+        }))
+            .refine(options => (!options.appId && !options.appObjectId && !options.appName) || options.appId || options.appName ||
+            (options.appObjectId && validation.isValidGuid(options.appObjectId)), options => ({
+            message: `The '${options.appObjectId}' must be a valid GUID`,
+            path: ['appObjectId']
+        }));
+    }
+    async commandAction(logger, args) {
+        try {
+            const appObjectId = await this.getAppObjectId(args.options);
+            if (args.options.verbose) {
+                await logger.logToStderr(`Adding directory extension to the app with id '${appObjectId}'...`);
+            }
+            const requestOptions = {
+                url: `${this.resource}/v1.0/applications/${appObjectId}/extensionProperties`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none',
+                    'content-type': 'application/json'
+                },
+                data: {
+                    name: args.options.name,
+                    dataType: args.options.dataType,
+                    targetObjects: args.options.targetObjects,
+                    isMultiValued: args.options.isMultiValued
+                },
+                responseType: 'json'
+            };
+            const res = await request.post(requestOptions);
+            await logger.log(res);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getAppObjectId(options) {
+        if (options.appObjectId) {
+            return options.appObjectId;
+        }
+        if (options.appId) {
+            return (await entraApp.getAppRegistrationByAppId(options.appId, ["id"])).id;
+        }
+        return (await entraApp.getAppRegistrationByAppName(options.appName, ["id"])).id;
+    }
+}
+export default new GraphDirectoryExtensionAddCommand();
+//# sourceMappingURL=directoryextension-add.js.map

package/dist/m365/graph/commands/directoryextension/directoryextension-get.js

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { globalOptionsZod } from '../../../../Command.js';
+import request from '../../../../request.js';
+import { zod } from '../../../../utils/zod.js';
+import commands from '../../commands.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import { validation } from '../../../../utils/validation.js';
+import { entraApp } from '../../../../utils/entraApp.js';
+import { directoryExtension } from '../../../../utils/directoryExtension.js';
+const options = globalOptionsZod
+    .extend({
+    id: zod.alias('i', z.string().refine(id => validation.isValidGuid(id), id => ({
+        message: `'${id}' is not a valid GUID.`
+    })).optional()),
+    name: zod.alias('n', z.string().optional()),
+    appId: z.string().refine(id => validation.isValidGuid(id), id => ({
+        message: `'${id}' is not a valid GUID.`
+    })).optional(),
+    appObjectId: z.string().refine(id => validation.isValidGuid(id), id => ({
+        message: `'${id}' is not a valid GUID.`
+    })).optional(),
+    appName: z.string().optional()
+})
+    .strict();
+class GraphDirectoryExtensionGetCommand extends GraphCommand {
+    get name() {
+        return commands.DIRECTORYEXTENSION_GET;
+    }
+    get description() {
+        return 'Retrieves the definition of a directory extension';
+    }
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(options => !options.id !== !options.name, {
+            message: 'Specify either id or name, but not both'
+        })
+            .refine(options => options.id || options.name, {
+            message: 'Specify either id or name'
+        })
+            .refine(options => Object.values([options.appId, options.appObjectId, options.appName]).filter(v => typeof v !== 'undefined').length === 1, {
+            message: 'Specify either appId, appObjectId or appName, but not multiple'
+        });
+    }
+    async commandAction(logger, args) {
+        try {
+            const appObjectId = await this.getAppObjectId(args.options);
+            let schemeExtensionId = args.options.id;
+            if (args.options.name) {
+                schemeExtensionId = (await directoryExtension.getDirectoryExtensionByName(args.options.name, appObjectId, ['id'])).id;
+            }
+            if (args.options.verbose) {
+                await logger.logToStderr(`Retrieving schema extension with ID ${schemeExtensionId} from application with ID ${appObjectId}...`);
+            }
+            const requestOptions = {
+                url: `${this.resource}/v1.0/applications/${appObjectId}/extensionProperties/${schemeExtensionId}`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json'
+            };
+            const res = await request.get(requestOptions);
+            await logger.log(res);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getAppObjectId(options) {
+        if (options.appObjectId) {
+            return options.appObjectId;
+        }
+        if (options.appId) {
+            return (await entraApp.getAppRegistrationByAppId(options.appId, ["id"])).id;
+        }
+        return (await entraApp.getAppRegistrationByAppName(options.appName, ["id"])).id;
+    }
+}
+export default new GraphDirectoryExtensionGetCommand();
+//# sourceMappingURL=directoryextension-get.js.map

package/dist/m365/graph/commands/directoryextension/directoryextension-remove.js

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import { globalOptionsZod } from '../../../../Command.js';
+import request from '../../../../request.js';
+import { zod } from '../../../../utils/zod.js';
+import commands from '../../commands.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import { validation } from '../../../../utils/validation.js';
+import { entraApp } from '../../../../utils/entraApp.js';
+import { cli } from '../../../../cli/cli.js';
+import { directoryExtension } from '../../../../utils/directoryExtension.js';
+const options = globalOptionsZod
+    .extend({
+    id: zod.alias('i', z.string().refine(id => validation.isValidGuid(id), id => ({
+        message: `'${id}' is not a valid GUID.`
+    })).optional()),
+    name: zod.alias('n', z.string().optional()),
+    appId: z.string().refine(id => validation.isValidGuid(id), id => ({
+        message: `'${id}' is not a valid GUID.`
+    })).optional(),
+    appObjectId: z.string().refine(id => validation.isValidGuid(id), id => ({
+        message: `'${id}' is not a valid GUID.`
+    })).optional(),
+    appName: z.string().optional(),
+    force: zod.alias('f', z.boolean().optional())
+})
+    .strict();
+class GraphDirectoryExtensionRemoveCommand extends GraphCommand {
+    get name() {
+        return commands.DIRECTORYEXTENSION_REMOVE;
+    }
+    get description() {
+        return 'Removes a directory extension';
+    }
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(options => !options.id !== !options.name, {
+            message: 'Specify either id or name, but not both'
+        })
+            .refine(options => options.id || options.name, {
+            message: 'Specify either id or name'
+        })
+            .refine(options => Object.values([options.appId, options.appObjectId, options.appName]).filter(v => typeof v !== 'undefined').length === 1, {
+            message: 'Specify either appId, appObjectId or appName, but not multiple'
+        });
+    }
+    async commandAction(logger, args) {
+        const removeDirectoryExtension = async () => {
+            try {
+                const appObjectId = await this.getAppObjectId(args.options);
+                let schemeExtensionId = args.options.id;
+                if (args.options.name) {
+                    schemeExtensionId = (await directoryExtension.getDirectoryExtensionByName(args.options.name, appObjectId, ['id'])).id;
+                }
+                if (args.options.verbose) {
+                    await logger.logToStderr(`Removing schema extension with ID ${schemeExtensionId} from application with ID ${appObjectId}...`);
+                }
+                const requestOptions = {
+                    url: `${this.resource}/v1.0/applications/${appObjectId}/extensionProperties/${schemeExtensionId}`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    }
+                };
+                await request.delete(requestOptions);
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        };
+        if (args.options.force) {
+            await removeDirectoryExtension();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove directory extension '${args.options.id || args.options.name}' from application '${args.options.appObjectId || args.options.appId || args.options.appName}'?` });
+            if (result) {
+                await removeDirectoryExtension();
+            }
+        }
+    }
+    async getAppObjectId(options) {
+        if (options.appObjectId) {
+            return options.appObjectId;
+        }
+        if (options.appId) {
+            return (await entraApp.getAppRegistrationByAppId(options.appId, ["id"])).id;
+        }
+        return (await entraApp.getAppRegistrationByAppName(options.appName, ["id"])).id;
+    }
+}
+export default new GraphDirectoryExtensionRemoveCommand();
+//# sourceMappingURL=directoryextension-remove.js.map

package/dist/m365/graph/commands.js

@@ -1,6 +1,9 @@
 const prefix = 'graph';
 export default {
     CHANGELOG_LIST: `${prefix} changelog list`,
+    DIRECTORYEXTENSION_ADD: `${prefix} directoryextension add`,
+    DIRECTORYEXTENSION_GET: `${prefix} directoryextension get`,
+    DIRECTORYEXTENSION_REMOVE: `${prefix} directoryextension remove`,
     SCHEMAEXTENSION_ADD: `${prefix} schemaextension add`,
     SCHEMAEXTENSION_GET: `${prefix} schemaextension get`,
     SCHEMAEXTENSION_LIST: `${prefix} schemaextension list`,

package/dist/m365/spo/commands/page/page-header-set.js

@@ -9,6 +9,7 @@ import { formatting } from '../../../../utils/formatting.js';
 import { validation } from '../../../../utils/validation.js';
 import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
+const BannerWebPartId = 'cbe7b0a9-3504-44dd-a3a3-0e5cacd07788';
 class SpoPageHeaderSetCommand extends SpoCommand {
     get name() {
         return commands.PAGE_HEADER_SET;
@@ -28,8 +29,8 @@ class SpoPageHeaderSetCommand extends SpoCommand {
     }
     async commandAction(logger, args) {
         const noPageHeader = {
-            "id": "cbe7b0a9-3504-44dd-a3a3-0e5cacd07788",
-            "instanceId": "cbe7b0a9-3504-44dd-a3a3-0e5cacd07788",
+            "id": BannerWebPartId,
+            "instanceId": BannerWebPartId,
             "title": "Title Region",
             "description": "Title Region Description",
             "serverProcessedContent": {
@@ -50,8 +51,8 @@ class SpoPageHeaderSetCommand extends SpoCommand {
             }
         };
         const defaultPageHeader = {
-            "id": "cbe7b0a9-3504-44dd-a3a3-0e5cacd07788",
-            "instanceId": "cbe7b0a9-3504-44dd-a3a3-0e5cacd07788",
+            "id": BannerWebPartId,
+            "instanceId": BannerWebPartId,
             "title": "Title Region",
             "description": "Title Region Description",
             "serverProcessedContent": {
@@ -72,8 +73,8 @@ class SpoPageHeaderSetCommand extends SpoCommand {
             }
         };
         const customPageHeader = {
-            "id": "cbe7b0a9-3504-44dd-a3a3-0e5cacd07788",
-            "instanceId": "cbe7b0a9-3504-44dd-a3a3-0e5cacd07788",
+            "id": BannerWebPartId,
+            "instanceId": BannerWebPartId,
             "title": "Title Region",
             "description": "Title Region Description",
             "serverProcessedContent": {
@@ -177,6 +178,14 @@ class SpoPageHeaderSetCommand extends SpoCommand {
                 title = pageData.Title;
                 topicHeader = topicHeader || pageData.TopicHeader || "";
             }
+            const pageControls = JSON.parse(pageData.CanvasContent1);
+            //In the new design page header is is a configurable Banner webpart in the first full-width section
+            const headerControl = pageControls.find(control => control?.position?.zoneIndex === 1 && control?.position?.sectionFactor === 0 && control?.webPartId === BannerWebPartId);
+            const isStandardPageHeader = pageData.LayoutWebpartsContent !== '[]';
+            //LayoutWebpartsContent represents standard page header
+            if (!isStandardPageHeader) {
+                header = headerControl?.webPartData || header;
+            }
             header.properties.title = title;
             header.properties.textAlignment = args.options.textAlignment || 'Left';
             header.properties.showTopicHeader = args.options.showTopicHeader || false;
@@ -232,8 +241,39 @@ class SpoPageHeaderSetCommand extends SpoCommand {
                 }
             }
             const requestBody = {
-                LayoutWebpartsContent: JSON.stringify([header])
+                LayoutWebpartsContent: JSON.stringify([header]),
+                CanvasContent1: canvasContent
             };
+            if (!isStandardPageHeader) {
+                requestBody.LayoutWebpartsContent = '[]';
+                header.properties.title = topicHeader;
+                if (headerControl) {
+                    headerControl.webPartData = header;
+                }
+                else {
+                    for (const pageControl of pageControls) {
+                        if (pageControl?.position?.sectionIndex) {
+                            pageControl.position.sectionIndex += pageControl.position.sectionIndex;
+                        }
+                    }
+                    pageControls.push({
+                        id: BannerWebPartId,
+                        controlType: 3,
+                        displayMode: 2,
+                        emphasis: {},
+                        position: {
+                            zoneIndex: 1,
+                            sectionFactor: 0,
+                            layoutIndex: 1,
+                            controlIndex: 1,
+                            sectionIndex: 1
+                        },
+                        webPartId: BannerWebPartId,
+                        webPartData: header
+                    });
+                }
+                requestBody.CanvasContent1 = JSON.stringify(pageControls);
+            }
             if (title) {
                 requestBody.Title = title;
             }
@@ -249,9 +289,6 @@ class SpoPageHeaderSetCommand extends SpoCommand {
             if (bannerImageUrl) {
                 requestBody.BannerImageUrl = bannerImageUrl;
             }
-            if (canvasContent) {
-                requestBody.CanvasContent1 = canvasContent;
-            }
             requestOptions = {
                 url: `${args.options.webUrl}/_api/sitepages/pages/GetByUrl('sitepages/${formatting.encodeQueryParameter(pageFullName)}')/SavePageAsDraft`,
                 headers: {

package/dist/m365/spo/commands/page/page-section-remove.js

@@ -0,0 +1,81 @@
+import { cli } from '../../../../cli/cli.js';
+import request from '../../../../request.js';
+import { spo } from '../../../../utils/spo.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+import { Page } from './Page.js';
+import { z } from 'zod';
+import { globalOptionsZod } from '../../../../Command.js';
+import { zod } from '../../../../utils/zod.js';
+const options = globalOptionsZod
+    .extend({
+    webUrl: zod.alias('u', z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, url => ({
+        message: `'${url}' is not a valid SharePoint Online site URL.`
+    }))),
+    pageName: zod.alias('n', z.string()),
+    section: zod.alias('s', z.number()),
+    force: zod.alias('f', z.boolean().optional())
+})
+    .strict();
+class SpoPageSectionRemoveCommand extends SpoCommand {
+    get name() {
+        return commands.PAGE_SECTION_REMOVE;
+    }
+    get description() {
+        return 'Removes the specified section from the modern page';
+    }
+    get schema() {
+        return options;
+    }
+    async commandAction(logger, args) {
+        if (args.options.force) {
+            await this.removeSection(logger, args);
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove section ${args.options.section} from '${args.options.pageName}'?` });
+            if (result) {
+                await this.removeSection(logger, args);
+            }
+        }
+    }
+    async removeSection(logger, args) {
+        try {
+            if (this.verbose) {
+                await logger.logToStderr(`Removing modern page section ${args.options.pageName} - ${args.options.section}...`);
+            }
+            const reqDigest = await spo.getRequestDigest(args.options.webUrl);
+            const clientSidePage = await Page.getPage(args.options.pageName, args.options.webUrl, logger, this.debug, this.verbose);
+            const sectionToDelete = clientSidePage.sections
+                .findIndex(section => section.order === args.options.section);
+            if (sectionToDelete === -1) {
+                throw new Error(`Section ${args.options.section} not found`);
+            }
+            clientSidePage.sections.splice(sectionToDelete, 1);
+            const updatedContent = clientSidePage.toHtml();
+            const requestOptions = {
+                url: `${args.options
+                    .webUrl}/_api/web/GetFileByServerRelativePath(DecodedUrl='${urlUtil.getServerRelativeSiteUrl(args.options.webUrl)}/sitepages/${args.options.pageName}')/ListItemAllFields`,
+                headers: {
+                    'X-RequestDigest': reqDigest.FormDigestValue,
+                    'content-type': 'application/json;odata=nometadata',
+                    'X-HTTP-Method': 'MERGE',
+                    'IF-MATCH': '*',
+                    accept: 'application/json;odata=nometadata'
+                },
+                data: {
+                    CanvasContent1: updatedContent
+                },
+                responseType: 'json'
+            };
+            return request.post(requestOptions);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new SpoPageSectionRemoveCommand();
+//# sourceMappingURL=page-section-remove.js.map

package/dist/m365/spo/commands.js

@@ -221,6 +221,7 @@ export default {
     PAGE_SECTION_ADD: `${prefix} page section add`,
     PAGE_SECTION_GET: `${prefix} page section get`,
     PAGE_SECTION_LIST: `${prefix} page section list`,
+    PAGE_SECTION_REMOVE: `${prefix} page section remove`,
     PAGE_TEMPLATE_LIST: `${prefix} page template list`,
     PAGE_TEMPLATE_REMOVE: `${prefix} page template remove`,
     PAGE_TEXT_ADD: `${prefix} page text add`,

package/dist/request.js

@@ -132,6 +132,7 @@ class Request {
             throw 'Logger not set on the request object';
         }
         this.updateRequestForCloudType(options, auth.connection.cloudType);
+        this.removeDoubleSlashes(options);
         try {
             let accessToken = '';
             if (options.headers && options.headers['x-anonymous']) {
@@ -187,6 +188,10 @@ class Request {
         const cloudUrl = Auth.getEndpointForResource(hostname, cloudType);
         options.url = options.url.replace(hostname, cloudUrl);
     }
+    removeDoubleSlashes(options) {
+        options.url = options.url.substring(0, 8) +
+            options.url.substring(8).replace('//', '/');
+    }
     createProxyConfigFromUrl(url) {
         const parsedUrl = new URL(url);
         const port = parsedUrl.port || (url.toLowerCase().startsWith('https') ? 443 : 80);

package/dist/utils/directoryExtension.js

@@ -0,0 +1,25 @@
+import { formatting } from './formatting.js';
+import { odata } from './odata.js';
+export const directoryExtension = {
+    /**
+     * Get a directory extension by its name registered for an application.
+     * @param name Role definition display name.
+     * @param appObjectId Application object id.
+     * @param properties List of properties to include in the response.
+     * @returns The directory extensions.
+     * @throws Error when directory extension was not found.
+     */
+    async getDirectoryExtensionByName(name, appObjectId, properties) {
+        let url = `https://graph.microsoft.com/v1.0/applications/${appObjectId}/extensionProperties?$filter=name eq '${formatting.encodeQueryParameter(name)}'`;
+        if (properties) {
+            url += `&$select=${properties.join(',')}`;
+        }
+        const extensionProperties = await odata.getAllItems(url);
+        if (extensionProperties.length === 0) {
+            throw `The specified directory extension '${name}' does not exist.`;
+        }
+        // there can be only one directory extension with a given name
+        return extensionProperties[0];
+    }
+};
+//# sourceMappingURL=directoryExtension.js.map

package/dist/utils/entraApp.js

@@ -1,6 +1,8 @@
 import fs from 'fs';
 import request from '../request.js';
 import { odata } from './odata.js';
+import { formatting } from './formatting.js';
+import { cli } from '../cli/cli.js';
 async function getCertificateBase64Encoded({ options, logger, debug }) {
     if (options.certificateBase64Encoded) {
         return options.certificateBase64Encoded;
@@ -278,6 +280,32 @@ export const entraApp = {
             await logger.logToStderr(`OAuth2 permissions: ${JSON.stringify(entraApp.appPermissions.flatMap(permission => permission.scope), null, 2)}`);
         }
         return resolvedApis;
+    },
+    async getAppRegistrationByAppId(appId, properties) {
+        let url = `https://graph.microsoft.com/v1.0/applications?$filter=appId eq '${appId}'`;
+        if (properties) {
+            url += `&$select=${properties.join(',')}`;
+        }
+        const apps = await odata.getAllItems(url);
+        if (apps.length === 0) {
+            throw `App with appId '${appId}' not found in Microsoft Entra ID`;
+        }
+        return apps[0];
+    },
+    async getAppRegistrationByAppName(appName, properties) {
+        let url = `https://graph.microsoft.com/v1.0/applications?$filter=displayName eq '${formatting.encodeQueryParameter(appName)}'`;
+        if (properties) {
+            url += `&$select=${properties.join(',')}`;
+        }
+        const apps = await odata.getAllItems(url);
+        if (apps.length === 0) {
+            throw `App with name '${appName}' not found in Microsoft Entra ID`;
+        }
+        if (apps.length > 1) {
+            const resultAsKeyValuePair = formatting.convertArrayToHashTable('id', apps);
+            return await cli.handleMultipleResultsFound(`Multiple apps with name '${appName}' found in Microsoft Entra ID.`, resultAsKeyValuePair);
+        }
+        return apps[0];
     }
 };
 //# sourceMappingURL=entraApp.js.map