@squiz/dxp-cli-next 5.31.0 → 5.32.0-develop.2

package/lib/migration/utils/createMigration.js

@@ -18,20 +18,27 @@ const path_1 = __importDefault(require("path"));
 const ApiService_1 = require("../../ApiService");
 const _1 = require(".");
 const child_process_1 = require("child_process");
-function createMigration(options) {
+/**
+ * Creates a new migration or pre-migration using the AI Page Migration service.
+ * Pre-migrations are used to generate specs for CCTs so they can be converted and deployed in advance.
+ * @param {CreateMigrationInput} input - The input parameters for the migration/pre-migration creation.
+ * @returns {Promise<CreateMigrationApiResponse>}
+ */
+function createMigration({ tenant, overrideUrl, assetId, previewAssetId, matrixUrl, cctIds, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const apiService = new ApiService_1.ApiService({
             validateStatus: _1.validateAxiosStatus,
         });
-        const migrationUrl = yield (0, _1.buildMigrationUrl)(options.tenant, options.overrideUrl);
+        const migrationUrl = yield (0, _1.buildMigrationUrl)(tenant, overrideUrl);
         try {
             const payload = {
-                assetId: options.assetId,
-                previewAssetId: options.previewAssetId,
-                matrixUrl: options.matrixUrl,
+                assetId,
+                previewAssetId,
+                matrixUrl,
+                cctIds,
             };
             const response = yield apiService.client.post(`${migrationUrl}`, payload, {
-                headers: yield (0, _1.getMigrationHeaders)(options.tenant),
+                headers: yield (0, _1.getMigrationHeaders)(tenant),
             });
             if (response.status !== 200 && response.status !== 201) {
                 throw new Error(`Migration creation failed with status: ${response.status}`);

package/lib/migration/utils/loadCctIdsFromFile.d.ts

@@ -0,0 +1 @@
+export declare const loadCctIdsFromFile: (filePath?: string) => string[] | undefined;

package/lib/migration/utils/loadCctIdsFromFile.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCctIdsFromFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const loadCctIdsFromFile = (filePath) => {
+    if (!filePath) {
+        return undefined;
+    }
+    try {
+        if (!fs_1.default.existsSync(filePath)) {
+            throw new Error(`CCT IDs file not found: ${filePath}`);
+        }
+        const fileContent = fs_1.default.readFileSync(filePath, 'utf8');
+        const cctIds = JSON.parse(fileContent);
+        if (!Array.isArray(cctIds) ||
+            cctIds.some(id => typeof id !== 'string' || !id.trim()) ||
+            cctIds.length === 0) {
+            throw new Error('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+        }
+        return cctIds;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to load CCT IDs from file: ${error.message}`);
+        }
+        throw new Error(`Failed to load CCT IDs from file: ${error}`);
+    }
+};
+exports.loadCctIdsFromFile = loadCctIdsFromFile;

package/lib/migration/utils/loadCctIdsFromFile.spec.d.ts

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

package/lib/migration/utils/loadCctIdsFromFile.spec.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const loadCctIdsFromFile_1 = require("./loadCctIdsFromFile");
+jest.mock('fs');
+const mockFs = fs_1.default;
+describe('loadCctIdsFromFile', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return undefined when no file path is provided', () => {
+        const result = (0, loadCctIdsFromFile_1.loadCctIdsFromFile)();
+        expect(result).toBeUndefined();
+    });
+    it('should load and parse valid JSON file with CCT IDs', () => {
+        const mockFilePath = '/test/path/cct-ids.json';
+        const mockJsonContent = '["cct-id-1", "cct-id-2", "cct-id-3"]';
+        const expectedResult = ['cct-id-1', 'cct-id-2', 'cct-id-3'];
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(mockJsonContent);
+        const result = (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath);
+        expect(mockFs.existsSync).toHaveBeenCalledWith(mockFilePath);
+        expect(mockFs.readFileSync).toHaveBeenCalledWith(mockFilePath, 'utf8');
+        expect(result).toEqual(expectedResult);
+    });
+    it('should throw error when file does not exist', () => {
+        const mockFilePath = '/test/path/nonexistent.json';
+        mockFs.existsSync.mockReturnValue(false);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow(`Failed to load CCT IDs from file: CCT IDs file not found: ${mockFilePath}`);
+    });
+    it('should throw error when JSON is invalid', () => {
+        const mockFilePath = '/test/path/invalid.json';
+        const invalidJson = '["invalid": json}';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(invalidJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('Failed to load CCT IDs from file:');
+    });
+    it('should throw error when JSON is not an array', () => {
+        const mockFilePath = '/test/path/object.json';
+        const objectJson = '{"id": "cct-id-1"}';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(objectJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+    });
+    it('should throw error when array is empty', () => {
+        const mockFilePath = '/test/path/empty.json';
+        const emptyArrayJson = '[]';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(emptyArrayJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+    });
+    it('should throw error when array contains non-string values', () => {
+        const mockFilePath = '/test/path/mixed.json';
+        const mixedArrayJson = '["cct-id-1", 123, "cct-id-3"]';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(mixedArrayJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+    });
+    it('should throw error when array contains empty strings', () => {
+        const mockFilePath = '/test/path/empty-strings.json';
+        const emptyStringsJson = '["cct-id-1", "", "cct-id-3"]';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(emptyStringsJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+    });
+    it('should throw error when array contains whitespace-only strings', () => {
+        const mockFilePath = '/test/path/whitespace.json';
+        const whitespaceJson = '["cct-id-1", "   ", "cct-id-3"]';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(whitespaceJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+    });
+    it('should throw error when JSON is null', () => {
+        const mockFilePath = '/test/path/null.json';
+        const nullJson = 'null';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(nullJson);
+        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+    });
+    it('should handle single CCT ID in array', () => {
+        const mockFilePath = '/test/path/single.json';
+        const singleIdJson = '["cct-id-only"]';
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue(singleIdJson);
+        const result = (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath);
+        expect(result).toEqual(['cct-id-only']);
+    });
+});

package/lib/migration/utils/options.d.ts

@@ -8,7 +8,8 @@ export declare enum OptionName {
     MATRIX_IDENTIFIER = "matrix-identifier",
     MATRIX_KEY = "matrix-key",
     CONTENT_API_KEY = "content-api-key",
-    STAGE_OPTIONS = "stage-options"
+    STAGE_OPTIONS = "stage-options",
+    CCT_IDS = "cct-ids"
 }
 export declare const getParamOption: (param: OptionName, makeOptionMandatory?: boolean) => Option;
 export declare const addOverrideUrlOption: (command: Command) => void;

package/lib/migration/utils/options.js

@@ -13,6 +13,7 @@ var OptionName;
     OptionName["MATRIX_KEY"] = "matrix-key";
     OptionName["CONTENT_API_KEY"] = "content-api-key";
     OptionName["STAGE_OPTIONS"] = "stage-options";
+    OptionName["CCT_IDS"] = "cct-ids";
 })(OptionName = exports.OptionName || (exports.OptionName = {}));
 const params = new Map([
     [
@@ -78,6 +79,13 @@ const params = new Map([
             description: 'Path to a JSON file containing stage options',
         },
     ],
+    [
+        OptionName.CCT_IDS,
+        {
+            flags: '--cct-ids <string>',
+            description: 'The IDs of the CCTs to be converted in a pre-migration, or to be skipped in a migration (already converted)',
+        },
+    ],
 ]);
 const getParamOption = (param, makeOptionMandatory = true) => {
     const paramInfo = params.get(param);

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

@@ -28,7 +28,7 @@ exports.logger = (0, dx_logger_lib_1.getLogger)({
 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('--config <string>', 'File path to the page layout config file'))
         .addOption(new commander_1.Option('-cu, --content-service-url <string>', 'Override the content service url from login')
         .env('CONTENT_SERVICE_URL')
         .hideHelp(true))
@@ -47,16 +47,25 @@ const createDeployCommand = () => {
             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;
+        let layoutFile = options.config;
+        (0, validation_1.validateLayoutFormat)(exports.logger, layoutFile);
+        if (!layoutFile) {
+            layoutFile = `./${definitions_1.LAYOUT_MANIFEST_FILE}`;
+        }
         exports.logger.info(`Loading layout data from the file ${layoutFile}`);
         try {
             const layout = yield (0, definitions_1.loadLayoutDefinition)(layoutFile);
             if (layout !== undefined) {
-                // Pre-deployment validation: check zones match between YAML and template
+                // Pre-deployment validation: check zones match between manifest and template
                 const zoneValidationError = (0, validation_1.validateZoneConsistency)(layout);
                 if (zoneValidationError) {
                     throw new Error(zoneValidationError);
                 }
+                // Validate Handlebars template only refers to properties if manifest.json is used
+                const propertyValidationError = (0, validation_1.validatePropertyConsistency)(layout, layoutFile);
+                if (propertyValidationError) {
+                    throw new Error(propertyValidationError);
+                }
                 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.`);
@@ -90,8 +99,34 @@ const createDeployCommand = () => {
     return deployCommand;
 };
 exports.default = createDeployCommand;
+/**
+ * Formats backend error responses into user-friendly error messages.
+ * Handles both validation errors (400s) and unknown server errors (500s).
+ *
+ * @param data - The error response data from the backend
+ * @param statusCode - The HTTP status code (optional)
+ * @returns Formatted error message string
+ */
+function formatErrorResponse(data, statusCode) {
+    // For 500 errors or unknown errors, show a generic message
+    if (statusCode && statusCode >= 500) {
+        return data.message || data.data || 'An unknown error occurred';
+    }
+    // For validation errors (400s), format with details
+    let errorMessage = data.message || 'Validation failed';
+    // Properties/options validation errors come as an object with field keys
+    if (data.details &&
+        typeof data.details === 'object' &&
+        !Array.isArray(data.details)) {
+        const details = Object.entries(data.details)
+            .map(([field, error]) => `  - ${field}: ${error.message}`)
+            .join('\n');
+        errorMessage += `\n${details}`;
+    }
+    return errorMessage;
+}
 function uploadLayout(client, layout, contentServiceUrl, dryRun) {
-    var _a, _b;
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const queryParam = dryRun ? '?_dryRun=true' : '';
@@ -101,13 +136,13 @@ function uploadLayout(client, layout, contentServiceUrl, dryRun) {
             if (response.status === 200) {
                 return response;
             }
-            const error = new Error(response.data.message);
-            if ((_b = (_a = response.data.details) === null || _a === void 0 ? void 0 : _a.input) === null || _b === void 0 ? void 0 : _b.message) {
-                error.message += `: ${response.data.details.input.message}`;
-            }
-            throw error;
+            throw new Error(formatErrorResponse(response.data, response.status));
         }
         catch (error) {
+            // Extract error details from axios error response
+            if ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) {
+                throw new Error(formatErrorResponse(error.response.data, error.response.status));
+            }
             throw error;
         }
     });

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

@@ -17,10 +17,12 @@ jest.mock('@squiz/dx-logger-lib', () => ({
     getLogger: () => {
         return {
             info: mockLoggerInfoFn,
+            warn: mockLoggerWarnFn,
         };
     },
 }));
 const mockLoggerInfoFn = jest.fn();
+const mockLoggerWarnFn = jest.fn();
 const nock_1 = __importDefault(require("nock"));
 const deploy_1 = __importDefault(require("./deploy"));
 const definitions_1 = require("../../utils/definitions");
@@ -58,7 +60,7 @@ describe('deployCommand', () => {
         const program = (0, deploy_1.default)();
         yield program.parseAsync(createMockArgs({}));
         const opts = program.opts();
-        expect(opts.config).toEqual('./page-layout.yaml');
+        expect(opts.config).toBeUndefined();
         expect(opts.tenant).toEqual('myTenant');
         expect(opts.dryRun).toEqual(false);
     }));
@@ -90,13 +92,17 @@ describe('deployCommand', () => {
         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 file = `./src/__tests__/layouts/${definitions_1.LAYOUT_MANIFEST_FILE}`;
         const dxpBaseUrl = 'http://dxp-base-url.com';
         const mockLayout = {
             name: 'test-layout',
-            zones: {
-                content: { displayName: 'Content', description: 'Main content' },
-            },
+            zones: [
+                {
+                    key: 'content',
+                    displayName: 'Content',
+                    description: 'Main content',
+                },
+            ],
             template: '<div>{{zones.content}}</div>',
         };
         const mockResponse = { name: 'test-layout', version: '12345' };
@@ -116,9 +122,13 @@ describe('deployCommand', () => {
         const dryRun = true;
         const mockLayout = {
             name: 'test-layout',
-            zones: {
-                content: { displayName: 'Content', description: 'Main content' },
-            },
+            zones: [
+                {
+                    key: 'content',
+                    displayName: 'Content',
+                    description: 'Main content',
+                },
+            ],
             template: '<div>{{zones.content}}</div>',
         };
         const mockResponse = { name: 'test-layout', version: '12345' };
@@ -170,7 +180,7 @@ describe('deployCommand', () => {
         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'));
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Internal server error'));
     }));
     it('should log additional details when layout validation fails', () => __awaiter(void 0, void 0, void 0, function* () {
         const dxpBaseUrl = 'http://dxp-base-url.com';
@@ -187,8 +197,53 @@ describe('deployCommand', () => {
         const program = (0, deploy_1.default)();
         errorSpy = jest.spyOn(program, 'error').mockImplementation();
         yield program.parseAsync(createMockArgs({ dxpBaseUrl }));
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Layout validation failed: ERROR: Validation failed: "version" is an excess property and therefore is not allowed'));
+        const errorCall = errorSpy.mock.calls[0][0];
+        expect(errorCall).toContain('- input: ERROR: Validation failed: "version" is an excess property and therefore is not allowed');
     }));
+    describe('backend property validation error reporting', () => {
+        it('should display clean error when single property validation fails', () => __awaiter(void 0, void 0, void 0, function* () {
+            const contentServiceUrl = 'http://localhost:9999';
+            (0, nock_1.default)(contentServiceUrl)
+                .post('/page-layout')
+                .reply(400, {
+                message: 'Validation failed',
+                details: {
+                    'input.properties.myBoolean': {
+                        message: "Property 'myBoolean' with type 'boolean' can not have values specified",
+                    },
+                },
+            });
+            const program = (0, deploy_1.default)();
+            errorSpy = jest.spyOn(program, 'error').mockImplementation();
+            yield program.parseAsync(createMockArgs({ contentServiceUrl }));
+            const errorCall = errorSpy.mock.calls[0][0];
+            expect(errorCall).toContain('Validation failed');
+            expect(errorCall).toContain("- input.properties.myBoolean: Property 'myBoolean' with type 'boolean' can not have values specified");
+        }));
+        it('should display multiple property validation errors cleanly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const contentServiceUrl = 'http://localhost:9999';
+            (0, nock_1.default)(contentServiceUrl)
+                .post('/page-layout')
+                .reply(400, {
+                message: 'Validation failed',
+                details: {
+                    'input.properties.badBoolean': {
+                        message: "Property 'badBoolean' with type 'boolean' cannot have enum values specified",
+                    },
+                    'input.properties.badProperty.type': {
+                        message: "Property 'badProperty' has invalid type 'INVALID'. Must be one of: string, boolean",
+                    },
+                },
+            });
+            const program = (0, deploy_1.default)();
+            errorSpy = jest.spyOn(program, 'error').mockImplementation();
+            yield program.parseAsync(createMockArgs({ contentServiceUrl }));
+            const errorCall = errorSpy.mock.calls[0][0];
+            expect(errorCall).toContain('Validation failed');
+            expect(errorCall).toContain("- input.properties.badBoolean: Property 'badBoolean' with type 'boolean' cannot have enum values specified");
+            expect(errorCall).toContain("- input.properties.badProperty.type: Property 'badProperty' has invalid type 'INVALID'. Must be one of: string, boolean");
+        }));
+    });
     describe('zone consistency validation', () => {
         it('should handle zone consistency validation errors where zones are used but not defined in the layout', () => __awaiter(void 0, void 0, void 0, function* () {
             const file = './src/__tests__/layout.yaml';
@@ -196,33 +251,69 @@ describe('deployCommand', () => {
             // Mock layout with zones that don't match the template
             const mockLayout = {
                 name: 'test-layout',
-                zones: {
-                    col1: { displayName: 'Column 1', description: 'The first column' },
-                },
+                zones: [
+                    {
+                        key: 'col1',
+                        displayName: 'Column 1',
+                        description: 'The first column',
+                    },
+                ],
                 template: '{{zones.col1}} {{zones.col2}}', // col2 is used but not defined in zones
             };
             definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
             const program = (0, deploy_1.default)();
             errorSpy = jest.spyOn(program, 'error').mockImplementation();
             yield program.parseAsync(createMockArgs({ config: file, dxpBaseUrl }));
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Zone consistency validation failed[\s\S]*Zones used in template but not defined in YAML: col2/));
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Zone consistency validation failed[\s\S]*Zones used in template but not defined in layout definition: col2/));
         }));
         it('should handle zone consistency validation errors where zones are defined but not used in the template', () => __awaiter(void 0, void 0, void 0, function* () {
             const file = './src/__tests__/layout.yaml';
             const dxpBaseUrl = 'http://dxp-base-url.com';
             const mockLayout = {
                 name: 'test-layout',
-                zones: {
-                    col1: { displayName: 'Column 1', description: 'The first column' },
-                    col2: { displayName: 'Column 2', description: 'The second column' }, // col2 is defined but not used in the template
-                },
+                zones: [
+                    {
+                        key: 'col1',
+                        displayName: 'Column 1',
+                        description: 'The first column',
+                    },
+                    {
+                        key: 'col2',
+                        displayName: 'Column 2',
+                        description: 'The second column',
+                    }, // col2 is defined but not used in the template
+                ],
                 template: '{{zones.col1}}',
             };
             definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
             const program = (0, deploy_1.default)();
             errorSpy = jest.spyOn(program, 'error').mockImplementation();
             yield program.parseAsync(createMockArgs({ config: file, dxpBaseUrl }));
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Zone consistency validation failed[\s\S]*Zones defined in YAML but not used in template: col2/));
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Zone consistency validation failed[\s\S]*Zones defined in layout definition but not used in template: col2/));
+        }));
+    });
+    describe('property consistency validation', () => {
+        it('should handle property consistency validation errors where properties are used but not defined in the layout', () => __awaiter(void 0, void 0, void 0, function* () {
+            const file = './src/__tests__/manifest.json';
+            const dxpBaseUrl = 'http://dxp-base-url.com';
+            // Mock layout with properties that don't match the template
+            const mockLayout = {
+                name: 'test-layout',
+                zones: [],
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '{{properties.title}} {{properties.undefined}}', // undefined is used but not defined in properties
+            };
+            definitions_1.loadLayoutDefinition.mockResolvedValue(mockLayout);
+            const program = (0, deploy_1.default)();
+            errorSpy = jest.spyOn(program, 'error').mockImplementation();
+            yield program.parseAsync(createMockArgs({ config: file, dxpBaseUrl }));
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Property consistency validation failed[\s\S]*Properties used in template but not defined in layout definition: undefined/));
         }));
     });
 });

package/lib/page/layouts/dev/dev.js

@@ -19,6 +19,7 @@ const definitions_1 = require("../../utils/definitions");
 const path_1 = __importDefault(require("path"));
 const server_1 = require("../../utils/server");
 const parse_args_1 = require("../../utils/parse-args");
+const validation_1 = require("../validation");
 exports.logger = (0, dx_logger_lib_1.getLogger)({
     name: 'layout-dev',
     format: 'human',
@@ -27,13 +28,13 @@ const createDevCommand = () => {
     const devCommand = new commander_1.Command()
         .name('dev')
         .description('Start a development server for page layouts')
-        .option('--config <string>', 'File path to the page layout config file', './page-layout.yaml')
+        .option('--config <string>', 'File path to the page layout config file', `./${definitions_1.LAYOUT_MANIFEST_FILE}`)
         .option('--port <number>', 'Port to run the development server on', '4040')
         .option('--no-open', 'Do not automatically open browser')
         .option('--stylesheet <path>', 'Path to CSS file to include')
         .option('--zones <items>', 'Zone content mappings', parse_args_1.parseZonesList, {})
-        .option('--options <items>', 'Layout options', parse_args_1.parseOptionsList, {})
-        .allowUnknownOption(true)
+        .option('--properties <items>', 'Layout properties', parse_args_1.parsePropertiesList, {})
+        .allowUnknownOption(false)
         .allowExcessArguments(true)
         .action((options) => __awaiter(void 0, void 0, void 0, function* () {
         try {
@@ -43,14 +44,27 @@ const createDevCommand = () => {
             if (!rawLayoutDefinition) {
                 throw new Error(`Failed to load layout definition from ${options.config}`);
             }
+            (0, validation_1.validateLayoutFormat)(exports.logger, options.config);
+            // Check zones match between manifest and template
+            const zoneValidationError = (0, validation_1.validateZoneConsistency)(rawLayoutDefinition);
+            if (zoneValidationError) {
+                throw new Error(zoneValidationError);
+            }
+            // Validate Handlebars template only refers to properties if manifest.json is used
+            const propertyValidationError = (0, validation_1.validatePropertyConsistency)(rawLayoutDefinition, options.config);
+            if (propertyValidationError) {
+                throw new Error(propertyValidationError);
+            }
             // Confirm for entry property
             const layoutDefinition = Object.assign({}, rawLayoutDefinition);
+            // Normalize properties to convert string booleans to actual booleans
+            const normalizedProperties = (0, parse_args_1.normalizeLayoutProperties)(options.properties, layoutDefinition);
             exports.logger.info('Starting development server...');
             yield (0, server_1.startDevServer)({
                 configPath: path_1.default.resolve(options.config),
                 layoutDefinition,
                 zoneContent: options.zones,
-                layoutOptions: options.options,
+                layoutProperties: normalizedProperties,
                 stylesheet: options.stylesheet
                     ? path_1.default.resolve(options.stylesheet)
                     : undefined,