@squiz/dxp-cli-next 5.23.1 → 5.24.0-develop.1

package/lib/__tests__/integration/main.spec.js

@@ -36,4 +36,12 @@ describe('dxp', () => {
             'porter         Porter Service Commands',
         ]);
     });
+    it('should show "page" command if ENABLE_PAGE_LAYOUTS="true"', () => {
+        var _a;
+        process.env.ENABLE_PAGE_LAYOUTS = 'true';
+        const { stdout } = (0, helpers_1.runCLI)(process.cwd(), ['--help']);
+        const commandsText = (_a = stdout
+            .match(/Commands\:(.*)/is)) === null || _a === void 0 ? void 0 : _a[1].split('\n').map(a => a.trim()).filter(a => !!a);
+        expect(commandsText).toContain('page           Page Content Service Commands');
+    });
 });

package/lib/datastore/blueprint/list/list.spec.js

@@ -29,6 +29,7 @@ describe('datastoreBlueprintList', () => {
             },
         ]);
         const program = (0, list_1.default)();
+        jest.spyOn(program, 'error').mockImplementation();
         yield program.parseAsync([
             'node',
             'dxp-cli',

package/lib/datastore/bundle/bundle.spec.js

@@ -66,6 +66,7 @@ describe('bundleJobContexts', () => {
             region: 'au',
         });
         const program = (0, bundle_1.default)();
+        jest.spyOn(program, 'error').mockImplementation();
         yield program.parseAsync([
             'node',
             'dxp-cli',

package/lib/dxp.js

@@ -17,6 +17,7 @@ const job_runner_1 = __importDefault(require("./job-runner"));
 const datastore_1 = __importDefault(require("./datastore"));
 const cdp_1 = __importDefault(require("./cdp"));
 const porter_1 = __importDefault(require("./porter"));
+const page_1 = __importDefault(require("./page"));
 const program = new commander_1.default.Command();
 const packageJson = require('../package.json');
 const version = packageJson.version;
@@ -32,6 +33,9 @@ program
 if (process.env.ENABLE_PORTER === 'true') {
     program.addCommand(porter_1.default);
 }
+if (process.env.ENABLE_PAGE_LAYOUTS === 'true') {
+    program.addCommand(page_1.default);
+}
 program
     .action(() => {
     program.help();

package/lib/job-runner/job/listJobs/listJobs.spec.js

@@ -21,6 +21,7 @@ describe('listJobs', () => {
             .get('/job/latest?&page%5Bsize%5D=5')
             .reply(200, [{ name: 'simple-job', type: 'job', version: '1.0.0' }]);
         const program = (0, listJobs_1.default)();
+        jest.spyOn(program, 'error').mockImplementation();
         yield program.parseAsync([
             'node',
             'dxp-cli',

package/lib/job-runner/job/uploadJob/uploadJob.spec.js

@@ -18,6 +18,7 @@ describe('upload job', () => {
     it('correctly displays the console logs for uploading the job', () => __awaiter(void 0, void 0, void 0, function* () {
         process.env.ENABLE_OVERRIDE_JOB_RUNNER_URL = 'true';
         const program = (0, uploadJob_1.default)();
+        jest.spyOn(program, 'error').mockImplementation();
         yield program.parseAsync([
             'node',
             'dxp-cli',

package/lib/job-runner/jobContext/listJobContexts.spec.js

@@ -40,6 +40,7 @@ describe('listJobContexts', () => {
             },
         ]);
         const program = (0, listJobContexts_1.default)();
+        jest.spyOn(program, 'error').mockImplementation();
         yield program.parseAsync([
             'node',
             'dxp-cli',

package/lib/job-runner/jobExecution/listJobExecutions/listJobExecutions.spec.js

@@ -43,6 +43,7 @@ describe('listJobExecutions', () => {
             },
         ]);
         const program = (0, listJobExecutions_1.default)();
+        jest.spyOn(program, 'error').mockImplementation();
         yield program.parseAsync([
             'node',
             'dxp-cli',

package/lib/job-runner/jobExecution/terminateJob/terminateJob.spec.js

@@ -32,6 +32,7 @@ describe('terminateJob', () => {
             version: '1.0.1',
         });
         const program = (0, terminateJob_1.default)();
+        jest.spyOn(program, 'error').mockImplementation();
         yield program.parseAsync([
             'node',
             'dxp-cli',

package/lib/page/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const pageCommand: Command;
+export default pageCommand;

package/lib/page/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const layouts_1 = __importDefault(require("./layouts/layouts"));
+const pageCommand = new commander_1.Command('page');
+pageCommand
+    .description('Page Content Service Commands')
+    .addCommand((0, layouts_1.default)());
+exports.default = pageCommand;

package/lib/page/layouts/deploy/deploy.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { Logger } from '@squiz/dx-logger-lib';
+export declare const logger: Logger;
+declare const createDeployCommand: () => Command;
+export default createDeployCommand;

package/lib/page/layouts/deploy/deploy.js

@@ -0,0 +1,108 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const commander_1 = require("commander");
+const cli_color_1 = __importDefault(require("cli-color"));
+const ApiService_1 = require("../../../ApiService");
+const ApplicationConfig_1 = require("../../../ApplicationConfig");
+const constants_1 = require("../../../constants");
+const definitions_1 = require("../../utils/definitions");
+const dx_logger_lib_1 = require("@squiz/dx-logger-lib");
+exports.logger = (0, dx_logger_lib_1.getLogger)({
+    name: 'upload-layout',
+    format: 'human',
+});
+const createDeployCommand = () => {
+    const deployCommand = new commander_1.Command()
+        .name('deploy')
+        .addOption(new commander_1.Option('--config <string>', 'File path to the page layout config file').default('./page-layout.yaml'))
+        .addOption(new commander_1.Option('-cu, --content-service-url <string>', 'Override the content service url from login')
+        .env('CONTENT_SERVICE_URL')
+        .hideHelp(true))
+        .addOption(new commander_1.Option('--dxp-base-url <baseURL>', 'DXP Console URL').env('DXP_BASE_URL'))
+        .addOption(new commander_1.Option('-t, --tenant <string>', 'Tenant ID to deploy to. If not provided will use configured tenant from login').env('SQUIZ_DXP_TENANT_ID'))
+        .addOption(new commander_1.Option('--dry-run', 'Run all pre-deployment processes without deploying').default(false))
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        if (options.contentServiceUrl) {
+            console.log(`NOTICE: CONTENT_SERVICE_URL is set and will deploy to ${options.contentServiceUrl}`);
+        }
+        const maybeConfig = yield maybeGetApplicationConfig();
+        const baseUrl = (_b = (_a = options.dxpBaseUrl) !== null && _a !== void 0 ? _a : maybeConfig === null || maybeConfig === void 0 ? void 0 : maybeConfig.baseUrl) !== null && _b !== void 0 ? _b : constants_1.PRODUCTION_URL;
+        const apiService = new ApiService_1.ApiService({
+            baseUrl,
+            tenantId: (_c = options.tenant) !== null && _c !== void 0 ? _c : maybeConfig === null || maybeConfig === void 0 ? void 0 : maybeConfig.tenant,
+        });
+        const contentServiceUrl = (_d = options.contentServiceUrl) !== null && _d !== void 0 ? _d : new URL('/__dxp/service/components-content', baseUrl).toString();
+        const layoutFile = options.config;
+        exports.logger.info(`Loading layout data from the file ${layoutFile}`);
+        try {
+            const layout = yield (0, definitions_1.loadLayoutDefinition)(layoutFile);
+            if (layout !== undefined) {
+                const response = yield uploadLayout(apiService.client, layout, contentServiceUrl, options.dryRun);
+                if (!options.dryRun) {
+                    exports.logger.info(`Layout "${layout.name}" version ${response.data.version} deployed successfully.`);
+                }
+                else {
+                    exports.logger.info(`Layout "${layout.name}" dry run successful.`);
+                }
+            }
+        }
+        catch (error) {
+            if (!!process.env.DEBUG && error.stack) {
+                deployCommand.error(error.stack);
+            }
+            if (error instanceof ApiService_1.InvalidLoginSessionError) {
+                deployCommand.error(cli_color_1.default.red('ERROR:', 'Login session expired. Please login again.'));
+            }
+            if (error instanceof ApiService_1.InvalidTenantError) {
+                deployCommand.error(cli_color_1.default.red('ERROR:', 'Cannot deploy to specified tenant'));
+            }
+            if (error.message) {
+                deployCommand.error(cli_color_1.default.red('ERROR:', error.message));
+            }
+            else {
+                deployCommand.error(cli_color_1.default.red('ERROR:', 'An unknown error occurred'));
+            }
+        }
+    }));
+    return deployCommand;
+};
+exports.default = createDeployCommand;
+function uploadLayout(client, layout, contentServiceUrl, dryRun) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const queryParam = dryRun ? '?_dryRun=true' : '';
+            const response = yield client.post('/page-layout' + queryParam, layout, {
+                baseURL: contentServiceUrl,
+            });
+            if (response.status === 200) {
+                return response;
+            }
+            throw new Error(response.data.message);
+        }
+        catch (error) {
+            throw error;
+        }
+    });
+}
+function maybeGetApplicationConfig() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield (0, ApplicationConfig_1.fetchApplicationConfig)();
+        }
+        catch (_a) { }
+    });
+}

package/lib/page/layouts/deploy/deploy.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/page/layouts/deploy/deploy.spec.js

@@ -0,0 +1,162 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('../../utils/definitions');
+jest.mock('@squiz/dx-logger-lib', () => ({
+    getLogger: () => {
+        return {
+            info: mockLoggerInfoFn,
+        };
+    },
+}));
+const mockLoggerInfoFn = jest.fn();
+const nock_1 = __importDefault(require("nock"));
+const deploy_1 = __importDefault(require("./deploy"));
+const definitions_1 = require("../../utils/definitions");
+function createMockArgs(opts) {
+    const args = ['node', 'dxp-cli', 'deploy'];
+    if (opts.config)
+        args.push('--config', opts.config);
+    if (opts.contentServiceUrl)
+        args.push('--content-service-url', opts.contentServiceUrl);
+    if (opts.tenant)
+        args.push('--tenant', opts.tenant);
+    if (opts.dxpBaseUrl)
+        args.push('--dxp-base-url', opts.dxpBaseUrl);
+    if (opts.dryRun)
+        args.push('--dry-run');
+    return args;
+}
+describe('deployCommand', () => {
+    let logSpy;
+    let errorSpy;
+    beforeAll(() => {
+        process.env.SQUIZ_DXP_TENANT_ID = 'myTenant';
+    });
+    beforeEach(() => {
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        if (!nock_1.default.isActive()) {
+            nock_1.default.activate();
+        }
+        nock_1.default.cleanAll();
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('correctly handles command option defaults', () => __awaiter(void 0, void 0, void 0, function* () {
+        const program = (0, deploy_1.default)();
+        yield program.parseAsync(createMockArgs({}));
+        const opts = program.opts();
+        expect(opts.config).toEqual('./page-layout.yaml');
+        expect(opts.tenant).toEqual('myTenant');
+        expect(opts.dryRun).toEqual(false);
+    }));
+    it('correctly handles command arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+        const config = './src/__tests__/layout.yaml';
+        const contentServiceUrl = 'http://localhost:9999';
+        const tenant = 'myTenant';
+        const dxpBaseUrl = 'http://dxp-base-url.com';
+        const dryRun = true;
+        const program = (0, deploy_1.default)();
+        yield program.parseAsync(createMockArgs({
+            config,
+            contentServiceUrl,
+            tenant,
+            dxpBaseUrl,
+            dryRun,
+        }));
+        const opts = program.opts();
+        expect(opts.config).toEqual(config);
+        expect(opts.contentServiceUrl).toEqual(contentServiceUrl);
+        expect(opts.tenant).toEqual(tenant);
+        expect(opts.dxpBaseUrl).toEqual(dxpBaseUrl);
+        expect(opts.dryRun).toEqual(true);
+    }));
+    it('logs a notice when contentServiceUrl is set', () => __awaiter(void 0, void 0, void 0, function* () {
+        const contentServiceUrl = 'http://localhost:9999';
+        const program = (0, deploy_1.default)();
+        yield program.parseAsync(createMockArgs({ contentServiceUrl }));
+        expect(logSpy).toHaveBeenCalledWith(`NOTICE: CONTENT_SERVICE_URL is set and will deploy to ${contentServiceUrl}`);
+    }));
+    it('deploys a layout successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+        const file = './src/__tests__/layouts/page-layout.yaml';
+        const dxpBaseUrl = 'http://dxp-base-url.com';
+        const mockLayout = { name: 'Test Layout' };
+        const mockResponse = { name: 'Test Layout', version: '12345' };
+        definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
+        (0, nock_1.default)(dxpBaseUrl + '/__dxp/service/components-content')
+            .post('/page-layout', mockLayout)
+            .reply(200, mockResponse);
+        const program = (0, deploy_1.default)();
+        yield program.parseAsync(createMockArgs({ config: file, dxpBaseUrl }));
+        expect(mockLoggerInfoFn).toHaveBeenNthCalledWith(1, `Loading layout data from the file ${file}`);
+        expect(mockLoggerInfoFn).toHaveBeenNthCalledWith(2, 'Layout "Test Layout" version 12345 deployed successfully.');
+    }));
+    it('deploys a layout with dry-run option', () => __awaiter(void 0, void 0, void 0, function* () {
+        const file = './src/__tests__/layout.yaml';
+        const dxpBaseUrl = 'http://dxp-base-url.com';
+        const dryRun = true;
+        const mockLayout = { name: 'Test Layout' };
+        const mockResponse = { name: 'Test Layout', version: '12345' };
+        definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
+        (0, nock_1.default)(dxpBaseUrl + '/__dxp/service/components-content')
+            .post('/page-layout', mockLayout)
+            .query({ _dryRun: 'true' })
+            .reply(200, mockResponse);
+        const program = (0, deploy_1.default)();
+        yield program.parseAsync(createMockArgs({ config: file, dxpBaseUrl, dryRun }));
+        expect(mockLoggerInfoFn).toHaveBeenNthCalledWith(1, `Loading layout data from the file ${file}`);
+        expect(mockLoggerInfoFn).toHaveBeenNthCalledWith(2, 'Layout "Test Layout" dry run successful.');
+    }));
+    it('handles InvalidLoginSessionError', () => __awaiter(void 0, void 0, void 0, function* () {
+        const dxpBaseUrl = 'http://dxp-base-url.com';
+        (0, nock_1.default)(dxpBaseUrl + '/__dxp/service/components-content')
+            .post('/page-layout')
+            .reply(401, { message: 'Invalid request: no session' });
+        const program = (0, deploy_1.default)();
+        errorSpy = jest.spyOn(program, 'error').mockImplementation();
+        yield program.parseAsync(createMockArgs({ dxpBaseUrl }));
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Login session expired. Please login again.'));
+    }));
+    it('handles InvalidTenantError', () => __awaiter(void 0, void 0, void 0, function* () {
+        const dxpBaseUrl = 'http://dxp-base-url.com';
+        (0, nock_1.default)(dxpBaseUrl + '/__dxp/service/components-content')
+            .post('/page-layout')
+            .reply(400, { message: 'Cannot deploy to specified tenant' });
+        const program = (0, deploy_1.default)();
+        errorSpy = jest.spyOn(program, 'error').mockImplementation();
+        yield program.parseAsync(createMockArgs({ dxpBaseUrl }));
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Cannot deploy to specified tenant'));
+    }));
+    it('handles errors with message', () => __awaiter(void 0, void 0, void 0, function* () {
+        const dxpBaseUrl = 'http://dxp-base-url.com';
+        (0, nock_1.default)(dxpBaseUrl + '/__dxp/service/components-content')
+            .post('/page-layout')
+            .reply(400, { message: 'Invalid layout data!' });
+        const program = (0, deploy_1.default)();
+        errorSpy = jest.spyOn(program, 'error').mockImplementation();
+        yield program.parseAsync(createMockArgs({ dxpBaseUrl }));
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid layout data!'));
+    }));
+    it('handles unknown errors', () => __awaiter(void 0, void 0, void 0, function* () {
+        const contentServiceUrl = 'http://localhost:9999';
+        (0, nock_1.default)(contentServiceUrl)
+            .post('/page-layout')
+            .reply(500, { data: 'Internal server error' });
+        const program = (0, deploy_1.default)();
+        errorSpy = jest.spyOn(program, 'error').mockImplementation();
+        yield program.parseAsync(createMockArgs({ contentServiceUrl }));
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('An unknown error occurred'));
+    }));
+});

package/lib/page/layouts/layouts.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const createLayoutsCommand: () => Command;
+export default createLayoutsCommand;

package/lib/page/layouts/layouts.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const deploy_1 = __importDefault(require("./deploy/deploy"));
+const createLayoutsCommand = () => {
+    const layoutsCommand = new commander_1.Command('layouts');
+    layoutsCommand
+        .description('Page Contents Layouts Commands')
+        .addCommand((0, deploy_1.default)());
+    return layoutsCommand;
+};
+exports.default = createLayoutsCommand;

package/lib/page/layouts/layouts.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/page/layouts/layouts.spec.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const layouts_1 = __importDefault(require("./layouts"));
+const deploy_1 = __importDefault(require("./deploy/deploy"));
+jest.mock('./deploy/deploy');
+deploy_1.default.mockImplementation(() => {
+    return new commander_1.Command('mock-deploy');
+});
+describe('createLayoutsCommand', () => {
+    it('should create a layouts command with deploy subcommand', () => {
+        const layoutsCommand = (0, layouts_1.default)();
+        expect(layoutsCommand).toBeInstanceOf(commander_1.Command);
+        expect(layoutsCommand.name()).toBe('layouts');
+        expect(layoutsCommand.description()).toBe('Page Contents Layouts Commands');
+        expect(deploy_1.default).toHaveBeenCalled();
+        expect(layoutsCommand.commands.map(cmd => cmd.name())).toContain('mock-deploy');
+    });
+});

package/lib/page/utils/definitions.d.ts

@@ -0,0 +1,264 @@
+import { z } from 'zod';
+export declare function loadLayoutDefinition(layoutFile: string): Promise<LayoutDefinition>;
+export declare const BaseLayoutDefinition: z.ZodObject<{
+    /**
+     * User defined identifier for a Page Layout
+     */
+    name: z.ZodString;
+    /**
+     * Name displayed in user interfaces
+     */
+    displayName: z.ZodString;
+    /**
+     * Description to provide extra information on the layout
+     */
+    description: z.ZodString;
+    /**
+     * Zone input structure configuration
+     *
+     * Declares the content structure that will be the input to the
+     * Handlebars template
+     */
+    zones: z.ZodRecord<z.ZodString, z.ZodObject<{
+        displayName: z.ZodString;
+        description: z.ZodString;
+        minNodes: z.ZodNumber;
+        maxNodes: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        displayName: string;
+        minNodes: number;
+        maxNodes?: number | undefined;
+    }, {
+        description: string;
+        displayName: string;
+        minNodes: number;
+        maxNodes?: number | undefined;
+    }>>;
+    /**
+     * Layout options
+     *
+     * Declares any configurable options that can be provided by a Content Editor
+     */
+    options: z.ZodRecord<z.ZodString, z.ZodObject<{
+        displayName: z.ZodString;
+        description: z.ZodString;
+        values: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        values: string[];
+        description: string;
+        displayName: string;
+    }, {
+        values: string[];
+        description: string;
+        displayName: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    options: Record<string, {
+        values: string[];
+        description: string;
+        displayName: string;
+    }>;
+    description: string;
+    displayName: string;
+    zones: Record<string, {
+        description: string;
+        displayName: string;
+        minNodes: number;
+        maxNodes?: number | undefined;
+    }>;
+}, {
+    name: string;
+    options: Record<string, {
+        values: string[];
+        description: string;
+        displayName: string;
+    }>;
+    description: string;
+    displayName: string;
+    zones: Record<string, {
+        description: string;
+        displayName: string;
+        minNodes: number;
+        maxNodes?: number | undefined;
+    }>;
+}>;
+export declare const InputLayoutDefinition: z.ZodObject<z.objectUtil.extendShape<{
+    /**
+     * User defined identifier for a Page Layout
+     */
+    name: z.ZodString;
+    /**
+     * Name displayed in user interfaces
+     */
+    displayName: z.ZodString;
+    /**
+     * Description to provide extra information on the layout
+     */
+    description: z.ZodString;
+    /**
+     * Zone input structure configuration
+     *
+     * Declares the content structure that will be the input to the
+     * Handlebars template
+     */
+    zones: z.ZodRecord<z.ZodString, z.ZodObject<{
+        displayName: z.ZodString;
+        description: z.ZodString;
+        minNodes: z.ZodNumber;
+        maxNodes: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        displayName: string;
+        minNodes: number;
+        maxNodes?: number | undefined;
+    }, {
+        description: string;
+        displayName: string;
+        minNodes: number;
+        maxNodes?: number | undefined;
+    }>>;
+    /**
+     * Layout options
+     *
+     * Declares any configurable options that can be provided by a Content Editor
+     */
+    options: z.ZodRecord<z.ZodString, z.ZodObject<{
+        displayName: z.ZodString;
+        description: z.ZodString;
+        values: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        values: string[];
+        description: string;
+        displayName: string;
+    }, {
+        values: string[];
+        description: string;
+        displayName: string;
+    }>>;
+}, {
+    entry: z.ZodString;
+}>, "strip", z.ZodTypeAny, {
+    name: string;
+    options: Record<string, {
+        values: string[];
+        description: string;
+        displayName: string;
+    }>;
+    entry: string;
+    description: string;
+    displayName: string;
+    zones: Record<string, {
+        description: string;
+        displayName: string;
+        minNodes: number;
+        maxNodes?: number | undefined;
+    }>;
+}, {
+    name: string;
+    options: Record<string, {
+        values: string[];
+        description: string;
+        displayName: string;
+    }>;
+    entry: string;
+    description: string;
+    displayName: string;
+    zones: Record<string, {
+        description: string;
+        displayName: string;
+        minNodes: number;
+        maxNodes?: number | undefined;
+    }>;
+}>;
+export declare const LayoutDefinition: z.ZodObject<z.objectUtil.extendShape<{
+    /**
+     * User defined identifier for a Page Layout
+     */
+    name: z.ZodString;
+    /**
+     * Name displayed in user interfaces
+     */
+    displayName: z.ZodString;
+    /**
+     * Description to provide extra information on the layout
+     */
+    description: z.ZodString;
+    /**
+     * Zone input structure configuration
+     *
+     * Declares the content structure that will be the input to the
+     * Handlebars template
+     */
+    zones: z.ZodRecord<z.ZodString, z.ZodObject<{
+        displayName: z.ZodString;
+        description: z.ZodString;
+        minNodes: z.ZodNumber;
+        maxNodes: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        displayName: string;
+        minNodes: number;
+        maxNodes?: number | undefined;
+    }, {
+        description: string;
+        displayName: string;
+        minNodes: number;
+        maxNodes?: number | undefined;
+    }>>;
+    /**
+     * Layout options
+     *
+     * Declares any configurable options that can be provided by a Content Editor
+     */
+    options: z.ZodRecord<z.ZodString, z.ZodObject<{
+        displayName: z.ZodString;
+        description: z.ZodString;
+        values: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        values: string[];
+        description: string;
+        displayName: string;
+    }, {
+        values: string[];
+        description: string;
+        displayName: string;
+    }>>;
+}, {
+    template: z.ZodString;
+}>, "strip", z.ZodTypeAny, {
+    name: string;
+    options: Record<string, {
+        values: string[];
+        description: string;
+        displayName: string;
+    }>;
+    description: string;
+    displayName: string;
+    zones: Record<string, {
+        description: string;
+        displayName: string;
+        minNodes: number;
+        maxNodes?: number | undefined;
+    }>;
+    template: string;
+}, {
+    name: string;
+    options: Record<string, {
+        values: string[];
+        description: string;
+        displayName: string;
+    }>;
+    description: string;
+    displayName: string;
+    zones: Record<string, {
+        description: string;
+        displayName: string;
+        minNodes: number;
+        maxNodes?: number | undefined;
+    }>;
+    template: string;
+}>;
+export declare type InputLayoutDefinition = z.infer<typeof InputLayoutDefinition>;
+export declare type LayoutDefinition = z.infer<typeof LayoutDefinition>;

package/lib/page/utils/definitions.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LayoutDefinition = exports.InputLayoutDefinition = exports.BaseLayoutDefinition = exports.loadLayoutDefinition = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const zod_1 = require("zod");
+const yaml_1 = require("yaml");
+function loadLayoutDefinition(layoutFile) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const _a = yield loadLayoutFromFile(layoutFile), { entry } = _a, layout = __rest(_a, ["entry"]);
+            const template = yield loadTemplate(path.dirname(layoutFile), entry);
+            const layoutDefinition = Object.assign(Object.assign({}, layout), { template });
+            exports.LayoutDefinition.parse(layoutDefinition);
+            return layoutDefinition;
+        }
+        catch (e) {
+            throw Error(`Failed loading layout definition: ${e.message}`);
+        }
+    });
+}
+exports.loadLayoutDefinition = loadLayoutDefinition;
+function loadLayoutFromFile(layoutFile) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fileType = layoutFile.split('.').pop();
+        if (!fileType || !['yaml', 'json'].includes(fileType)) {
+            throw Error('Layout file must have a valid extension: [yaml|json]');
+        }
+        const content = yield fs.readFile(layoutFile, {
+            encoding: 'utf-8',
+        });
+        try {
+            const layout = (0, yaml_1.parse)(content);
+            exports.InputLayoutDefinition.parse(layout);
+            return layout;
+        }
+        catch (e) {
+            throw Error(`Failed to parse ${layoutFile}: ${e.message}`);
+        }
+    });
+}
+function loadTemplate(layoutDirectory, templateFile) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield fs.readFile(path.resolve(layoutDirectory, templateFile), {
+                encoding: 'utf-8',
+            });
+        }
+        catch (e) {
+            throw Error(`Failed loading template file "${templateFile}": ${e.message}`);
+        }
+    });
+}
+exports.BaseLayoutDefinition = zod_1.z.object({
+    /**
+     * User defined identifier for a Page Layout
+     */
+    name: zod_1.z.string().regex(/^[a-z][a-z0-9-_]*[a-z0-9]$/),
+    /**
+     * Name displayed in user interfaces
+     */
+    displayName: zod_1.z.string(),
+    /**
+     * Description to provide extra information on the layout
+     */
+    description: zod_1.z.string(),
+    /**
+     * Zone input structure configuration
+     *
+     * Declares the content structure that will be the input to the
+     * Handlebars template
+     */
+    zones: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+        displayName: zod_1.z.string(),
+        description: zod_1.z.string(),
+        minNodes: zod_1.z.number().min(0),
+        maxNodes: zod_1.z.number().min(1).optional(),
+    })),
+    /**
+     * Layout options
+     *
+     * Declares any configurable options that can be provided by a Content Editor
+     */
+    options: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+        displayName: zod_1.z.string(),
+        description: zod_1.z.string(),
+        values: zod_1.z.array(zod_1.z.string()),
+    })),
+});
+exports.InputLayoutDefinition = exports.BaseLayoutDefinition.extend({
+    entry: zod_1.z.string(),
+});
+exports.LayoutDefinition = exports.BaseLayoutDefinition.extend({
+    template: zod_1.z.string(),
+});

package/lib/page/utils/definitions.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/page/utils/definitions.spec.js

@@ -0,0 +1,290 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs/promises"));
+const definitions_1 = require("./definitions");
+jest.mock('node:fs/promises');
+describe('loadLayoutDefinition', () => {
+    const paintLayoutFileYaml = './some-dir/page-layout.yaml';
+    const paintLayoutFileJson = './some-dir/page-layout.json';
+    const yamlContent = `
+name: test-layout
+displayName: Test Layout
+description: A test layout
+zones:
+  main:
+    displayName: Main Zone
+    description: Main content area
+    minNodes: 1
+options:
+  color:
+    displayName: Color
+    description: Color options
+    values: ['red', 'blue']
+entry: template.hbs
+  `;
+    // missing "name" field
+    const yamlContentInvalidLayout = `
+displayName: Test Layout
+description: A test layout
+zones:
+  main:
+    displayName: Main Zone
+    description: Main content area
+    minNodes: 1
+options:
+  color:
+    displayName: Color
+    description: Color options
+    values: ['red', 'blue']
+entry: template.hbs
+  `;
+    const jsonContent = JSON.stringify({
+        name: 'test-layout',
+        displayName: 'Test Layout',
+        description: 'A test layout',
+        zones: {
+            main: {
+                displayName: 'Main Zone',
+                description: 'Main content area',
+                minNodes: 1,
+            },
+        },
+        options: {
+            color: {
+                displayName: 'Color',
+                description: 'Color options',
+                values: ['red', 'blue'],
+            },
+        },
+        entry: 'template.hbs',
+    });
+    // missing "name" field
+    const jsonContentInvalidLayout = JSON.stringify({
+        displayName: 'Test Layout',
+        description: 'A test layout',
+        zones: {
+            main: {
+                displayName: 'Main Zone',
+                description: 'Main content area',
+                minNodes: 1,
+            },
+        },
+        options: {
+            color: {
+                displayName: 'Color',
+                description: 'Color options',
+                values: ['red', 'blue'],
+            },
+        },
+        entry: 'template.hbs',
+    });
+    const templateContent = '<div>{{content}}</div>';
+    beforeEach(() => {
+        jest.resetAllMocks();
+    });
+    it('should load layout definition from YAML file', () => __awaiter(void 0, void 0, void 0, function* () {
+        fs.readFile.mockImplementation((filePath) => {
+            if (filePath.endsWith('page-layout.yaml')) {
+                return yamlContent;
+            }
+            if (filePath.endsWith('template.hbs')) {
+                return templateContent;
+            }
+            throw new Error('File not found');
+        });
+        const layoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(paintLayoutFileYaml);
+        expect(layoutDefinition).toEqual({
+            name: 'test-layout',
+            displayName: 'Test Layout',
+            description: 'A test layout',
+            zones: {
+                main: {
+                    displayName: 'Main Zone',
+                    description: 'Main content area',
+                    minNodes: 1,
+                },
+            },
+            options: {
+                color: {
+                    displayName: 'Color',
+                    description: 'Color options',
+                    values: ['red', 'blue'],
+                },
+            },
+            template: templateContent,
+        });
+    }));
+    it('should load layout definition from JSON file', () => __awaiter(void 0, void 0, void 0, function* () {
+        fs.readFile.mockImplementation((filePath) => {
+            if (filePath.endsWith('page-layout.yaml')) {
+                throw { code: 'ENOENT' };
+            }
+            if (filePath.endsWith('page-layout.json')) {
+                return jsonContent;
+            }
+            if (filePath.endsWith('template.hbs')) {
+                return templateContent;
+            }
+            throw new Error('File not found');
+        });
+        const layoutDefinition = yield (0, definitions_1.loadLayoutDefinition)(paintLayoutFileJson);
+        expect(layoutDefinition).toEqual({
+            name: 'test-layout',
+            displayName: 'Test Layout',
+            description: 'A test layout',
+            zones: {
+                main: {
+                    displayName: 'Main Zone',
+                    description: 'Main content area',
+                    minNodes: 1,
+                },
+            },
+            options: {
+                color: {
+                    displayName: 'Color',
+                    description: 'Color options',
+                    values: ['red', 'blue'],
+                },
+            },
+            template: templateContent,
+        });
+    }));
+    it('should throw validation error if invalid data for YAML', () => __awaiter(void 0, void 0, void 0, function* () {
+        fs.readFile.mockImplementation((filePath) => {
+            if (filePath.endsWith('page-layout.yaml')) {
+                return yamlContentInvalidLayout;
+            }
+            if (filePath.endsWith('template.hbs')) {
+                return templateContent;
+            }
+            throw new Error('File not found');
+        });
+        yield expect((0, definitions_1.loadLayoutDefinition)(paintLayoutFileYaml)).rejects
+            .toThrowErrorMatchingInlineSnapshot(`
+      "Failed loading layout definition: Failed to parse ./some-dir/page-layout.yaml: [
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "received": "undefined",
+          "path": [
+            "name"
+          ],
+          "message": "Required"
+        }
+      ]"
+    `);
+    }));
+    it('should throw validation error if invalid data for JSON', () => __awaiter(void 0, void 0, void 0, function* () {
+        fs.readFile.mockImplementation((filePath) => {
+            if (filePath.endsWith('page-layout.json')) {
+                return jsonContentInvalidLayout;
+            }
+            if (filePath.endsWith('template.hbs')) {
+                return templateContent;
+            }
+            throw new Error('File not found');
+        });
+        yield expect((0, definitions_1.loadLayoutDefinition)(paintLayoutFileJson)).rejects
+            .toThrowErrorMatchingInlineSnapshot(`
+      "Failed loading layout definition: Failed to parse ./some-dir/page-layout.json: [
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "received": "undefined",
+          "path": [
+            "name"
+          ],
+          "message": "Required"
+        }
+      ]"
+    `);
+    }));
+    it('should throw an error if YAML layout file has invalid YAML', () => __awaiter(void 0, void 0, void 0, function* () {
+        fs.readFile.mockImplementation((filePath) => {
+            if (filePath.endsWith('page-layout.yaml')) {
+                return 'name: invalid yaml, entry: template.hbs';
+            }
+            if (filePath.endsWith('page-layout.json')) {
+                return jsonContent;
+            }
+            if (filePath.endsWith('template.hbs')) {
+                return templateContent;
+            }
+            throw new Error('File not found');
+        });
+        yield expect((0, definitions_1.loadLayoutDefinition)(paintLayoutFileYaml)).rejects
+            .toThrowErrorMatchingInlineSnapshot(`
+      "Failed loading layout definition: Failed to parse ./some-dir/page-layout.yaml: Nested mappings are not allowed in compact mappings at line 1, column 7:
+
+      name: invalid yaml, entry: template.hbs
+            ^
+      "
+    `);
+    }));
+    it('should throw an error if JSON layout file has invalid JSON', () => __awaiter(void 0, void 0, void 0, function* () {
+        fs.readFile.mockImplementation((filePath) => {
+            if (filePath.endsWith('page-layout.yaml')) {
+                throw { code: 'ENOENT' };
+            }
+            if (filePath.endsWith('page-layout.json')) {
+                return '{invalid: json';
+            }
+            if (filePath.endsWith('template.hbs')) {
+                return templateContent;
+            }
+            throw new Error('File not found');
+        });
+        yield expect((0, definitions_1.loadLayoutDefinition)(paintLayoutFileJson)).rejects
+            .toThrowErrorMatchingInlineSnapshot(`
+      "Failed loading layout definition: Failed to parse ./some-dir/page-layout.json: Flow map must end with a } at line 1, column 15:
+
+      {invalid: json
+                    ^
+      "
+    `);
+    }));
+    it('should throw an error if layout file do not have valid extension', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield expect((0, definitions_1.loadLayoutDefinition)('/foo/paint-layout.html')).rejects.toThrow('Layout file must have a valid extension: [yaml|json]');
+    }));
+    it('should throw an error if template file is not found', () => __awaiter(void 0, void 0, void 0, function* () {
+        fs.readFile.mockImplementation((filePath) => {
+            if (filePath.endsWith('page-layout.yaml')) {
+                return yamlContent;
+            }
+            throw Error('File not found');
+        });
+        yield expect((0, definitions_1.loadLayoutDefinition)(paintLayoutFileYaml)).rejects.toThrow('Failed loading layout definition: Failed loading template file "template.hbs": File not found');
+    }));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/dxp-cli-next",
-  "version": "5.23.1",
+  "version": "5.24.0-develop.1",
   "repository": {
     "url": "https://gitlab.squiz.net/dxp/dxp-cli-next"
   },
@@ -44,6 +44,7 @@
     "@squiz/component-cli-lib": "1.72.6",
     "@squiz/dxp-porter-shared": "0.4.0",
     "@squiz/local-component-dev-ui": "0.6.18",
+    "@squiz/dx-logger-lib": "^1.65.1",
     "axios": "1.1.3",
     "cli-color": "2.0.3",
     "commander": "9.4.0",