@squiz/dxp-cli-next 5.30.0-develop.1 → 5.30.0-develop.3

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

@@ -19,6 +19,7 @@ const ApiService_1 = require("../../../ApiService");
 const ApplicationConfig_1 = require("../../../ApplicationConfig");
 const constants_1 = require("../../../constants");
 const definitions_1 = require("../../utils/definitions");
+const validation_1 = require("../validation");
 const dx_logger_lib_1 = require("@squiz/dx-logger-lib");
 exports.logger = (0, dx_logger_lib_1.getLogger)({
     name: 'upload-layout',
@@ -35,7 +36,7 @@ const createDeployCommand = () => {
         .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;
+        var _a, _b, _c, _d, _e;
         if (options.contentServiceUrl) {
             console.log(`NOTICE: CONTENT_SERVICE_URL is set and will deploy to ${options.contentServiceUrl}`);
         }
@@ -52,13 +53,16 @@ const createDeployCommand = () => {
             const layout = yield (0, definitions_1.loadLayoutDefinition)(layoutFile);
             if (layout !== undefined) {
                 // Pre-deployment validation: check zones match between YAML and template
-                const zoneValidationError = validateZoneConsistency(layout);
+                const zoneValidationError = (0, validation_1.validateZoneConsistency)(layout);
                 if (zoneValidationError) {
                     throw new Error(zoneValidationError);
                 }
                 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.`);
+                    // Log the deployed layout URL (clickable)
+                    const layoutUrl = `${baseUrl}/organization/${(_e = options.tenant) !== null && _e !== void 0 ? _e : maybeConfig === null || maybeConfig === void 0 ? void 0 : maybeConfig.tenant}/component-service/all-layouts/${encodeURIComponent(layout.name)}`;
+                    exports.logger.info(`Deployed layout URL: \u001b]8;;${layoutUrl}\u001b\\${layoutUrl}\u001b]8;;\u001b\\`);
                 }
                 else {
                     exports.logger.info(`Layout "${layout.name}" dry run successful.`);
@@ -87,6 +91,7 @@ const createDeployCommand = () => {
 };
 exports.default = createDeployCommand;
 function uploadLayout(client, layout, contentServiceUrl, dryRun) {
+    var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const queryParam = dryRun ? '?_dryRun=true' : '';
@@ -96,7 +101,11 @@ function uploadLayout(client, layout, contentServiceUrl, dryRun) {
             if (response.status === 200) {
                 return response;
             }
-            throw new Error(response.data.message);
+            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;
         }
         catch (error) {
             throw error;
@@ -111,48 +120,3 @@ function maybeGetApplicationConfig() {
         catch (_a) { }
     });
 }
-/**
- * Validates that zones defined in YAML match zones used in the Handlebars template
- * @param layout The layout definition containing zones and template
- * @returns Error message if validation fails, null if validation passes
- */
-function validateZoneConsistency(layout) {
-    const yamlZones = Object.keys(layout.zones || {});
-    const template = layout.template;
-    // If no template is provided, skip validation
-    if (!template) {
-        return null;
-    }
-    // Extract zone references from Handlebars template
-    // Look for patterns like {{#each zones.zoneName}}, {{zones.zoneName}}, {{#if zones.zoneName}}
-    const zonePattern = /\{\{(?:#(?:each|if)\s+)?zones\.(\w+)/g;
-    const templateZones = new Set();
-    let match;
-    // Loop through the template and extract the zone names
-    while ((match = zonePattern.exec(template)) !== null) {
-        templateZones.add(match[1]);
-    }
-    // Convert the set to an array
-    const templateZoneArray = Array.from(templateZones);
-    // Find zones defined in YAML but not used in template
-    const unusedYamlZones = yamlZones.filter(zone => !templateZones.has(zone));
-    // Find zones used in template but not defined in YAML
-    const undefinedTemplateZones = templateZoneArray.filter(zone => !yamlZones.includes(zone));
-    // Create an array of errors
-    const errors = [];
-    // Add the unused zones to the errors
-    if (unusedYamlZones.length > 0) {
-        errors.push(`Zones defined in YAML but not used in template: ${unusedYamlZones.join(', ')}`);
-    }
-    // Add the undefined zones to the errors
-    if (undefinedTemplateZones.length > 0) {
-        errors.push(`Zones used in template but not defined in YAML: ${undefinedTemplateZones.join(', ')}`);
-    }
-    // If there are errors, return the errors
-    if (errors.length > 0) {
-        return `Zone consistency validation failed:\n${errors
-            .map(err => `  - ${err}`)
-            .join('\n')}`;
-    }
-    return null;
-}

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

@@ -93,13 +93,13 @@ describe('deployCommand', () => {
         const file = './src/__tests__/layouts/page-layout.yaml';
         const dxpBaseUrl = 'http://dxp-base-url.com';
         const mockLayout = {
-            name: 'Test Layout',
+            name: 'test-layout',
             zones: {
                 content: { displayName: 'Content', description: 'Main content' },
             },
             template: '<div>{{zones.content}}</div>',
         };
-        const mockResponse = { name: 'Test Layout', version: '12345' };
+        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)
@@ -107,20 +107,21 @@ describe('deployCommand', () => {
         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.');
+        expect(mockLoggerInfoFn).toHaveBeenNthCalledWith(2, 'Layout "test-layout" version 12345 deployed successfully.');
+        expect(mockLoggerInfoFn).toHaveBeenNthCalledWith(3, 'Deployed layout URL: \u001b]8;;http://dxp-base-url.com/organization/myTenant/component-service/all-layouts/test-layout\u001b\\http://dxp-base-url.com/organization/myTenant/component-service/all-layouts/test-layout\u001b]8;;\u001b\\');
     }));
     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',
+            name: 'test-layout',
             zones: {
                 content: { displayName: 'Content', description: 'Main content' },
             },
             template: '<div>{{zones.content}}</div>',
         };
-        const mockResponse = { name: 'Test Layout', version: '12345' };
+        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)
@@ -129,7 +130,7 @@ describe('deployCommand', () => {
         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.');
+        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';
@@ -171,13 +172,30 @@ describe('deployCommand', () => {
         yield program.parseAsync(createMockArgs({ contentServiceUrl }));
         expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('An unknown error occurred'));
     }));
+    it('should log additional details when layout validation fails', () => __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: 'Layout validation failed',
+            details: {
+                input: {
+                    message: 'ERROR: Validation failed: "version" is an excess property and therefore is not allowed',
+                },
+            },
+        });
+        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'));
+    }));
     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';
             const dxpBaseUrl = 'http://dxp-base-url.com';
             // Mock layout with zones that don't match the template
             const mockLayout = {
-                name: 'Test Layout',
+                name: 'test-layout',
                 zones: {
                     col1: { displayName: 'Column 1', description: 'The first column' },
                 },
@@ -193,7 +211,7 @@ describe('deployCommand', () => {
             const file = './src/__tests__/layout.yaml';
             const dxpBaseUrl = 'http://dxp-base-url.com';
             const mockLayout = {
-                name: 'Test Layout',
+                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

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

@@ -0,0 +1 @@
+export { validateZoneConsistency } from './zone-consistency';

package/lib/page/layouts/validation/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateZoneConsistency = void 0;
+var zone_consistency_1 = require("./zone-consistency");
+Object.defineProperty(exports, "validateZoneConsistency", { enumerable: true, get: function () { return zone_consistency_1.validateZoneConsistency; } });

package/lib/page/layouts/validation/zone-consistency.d.ts

@@ -0,0 +1,7 @@
+import { LayoutDefinition } from '../../utils/definitions';
+/**
+ * Validates that zones defined in YAML match zones used in the Handlebars template
+ * @param layout The layout definition containing zones and template
+ * @returns Error message if validation fails, null if validation passes
+ */
+export declare function validateZoneConsistency(layout: LayoutDefinition): string | null;

package/lib/page/layouts/validation/zone-consistency.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateZoneConsistency = void 0;
+/**
+ * Validates that zones defined in YAML match zones used in the Handlebars template
+ * @param layout The layout definition containing zones and template
+ * @returns Error message if validation fails, null if validation passes
+ */
+function validateZoneConsistency(layout) {
+    const yamlZones = Object.keys(layout.zones || {});
+    const template = layout.template;
+    // If no template is provided, skip validation
+    if (!template) {
+        return null;
+    }
+    // Extract zone references from Handlebars template
+    // Look for patterns like {{#each zones.zoneName}}, {{zones.zoneName}}, {{#if zones.zoneName}}
+    const zonePattern = /\{\{(?:#(?:each|if)\s+)?zones\.(\w+)/g;
+    const templateZones = new Set();
+    let match;
+    // Loop through the template and extract the zone names
+    while ((match = zonePattern.exec(template)) !== null) {
+        templateZones.add(match[1]);
+    }
+    // Convert the set to an array
+    const templateZoneArray = Array.from(templateZones);
+    // Find zones defined in YAML but not used in template
+    const unusedYamlZones = yamlZones.filter(zone => !templateZones.has(zone));
+    // Find zones used in template but not defined in YAML
+    const undefinedTemplateZones = templateZoneArray.filter(zone => !yamlZones.includes(zone));
+    // Create an array of errors
+    const errors = [];
+    // Add the unused zones to the errors
+    if (unusedYamlZones.length > 0) {
+        errors.push(`Zones defined in YAML but not used in template: ${unusedYamlZones.join(', ')}`);
+    }
+    // Add the undefined zones to the errors
+    if (undefinedTemplateZones.length > 0) {
+        errors.push(`Zones used in template but not defined in YAML: ${undefinedTemplateZones.join(', ')}`);
+    }
+    // If there are errors, return the errors
+    if (errors.length > 0) {
+        return `Zone consistency validation failed:\n${errors
+            .map(err => `  - ${err}`)
+            .join('\n')}`;
+    }
+    return null;
+}
+exports.validateZoneConsistency = validateZoneConsistency;

package/lib/page/layouts/validation/zone-consistency.spec.d.ts

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

package/lib/page/layouts/validation/zone-consistency.spec.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zone_consistency_1 = require("./zone-consistency");
+describe('validateZoneConsistency', () => {
+    const createMockLayout = (zones, template) => ({
+        name: 'test-layout',
+        displayName: 'Test Layout',
+        description: 'A test layout',
+        zones,
+        template,
+    });
+    it('should return null for valid zone consistency', () => {
+        const layout = createMockLayout({
+            header: { displayName: 'Header', description: 'Header zone' },
+            content: { displayName: 'Content', description: 'Content zone' },
+        }, '<div>{{zones.header}}</div><div>{{zones.content}}</div>');
+        const result = (0, zone_consistency_1.validateZoneConsistency)(layout);
+        expect(result).toBeNull();
+    });
+    it('should return null when no template is provided', () => {
+        const layout = createMockLayout({
+            header: { displayName: 'Header', description: 'Header zone' },
+        }, '');
+        const result = (0, zone_consistency_1.validateZoneConsistency)(layout);
+        expect(result).toBeNull();
+    });
+    it('should detect zones defined in YAML but not used in template', () => {
+        const layout = createMockLayout({
+            header: { displayName: 'Header', description: 'Header zone' },
+            sidebar: { displayName: 'Sidebar', description: 'Sidebar zone' },
+        }, '<div>{{zones.header}}</div>');
+        const result = (0, zone_consistency_1.validateZoneConsistency)(layout);
+        expect(result).toContain('Zone consistency validation failed');
+        expect(result).toContain('Zones defined in YAML but not used in template: sidebar');
+    });
+    it('should detect zones used in template but not defined in YAML', () => {
+        const layout = createMockLayout({
+            header: { displayName: 'Header', description: 'Header zone' },
+        }, '<div>{{zones.header}}</div><div>{{zones.footer}}</div>');
+        const result = (0, zone_consistency_1.validateZoneConsistency)(layout);
+        expect(result).toContain('Zone consistency validation failed');
+        expect(result).toContain('Zones used in template but not defined in YAML: footer');
+    });
+    it('should detect both unused and undefined zones', () => {
+        const layout = createMockLayout({
+            header: { displayName: 'Header', description: 'Header zone' },
+            sidebar: { displayName: 'Sidebar', description: 'Sidebar zone' },
+        }, '<div>{{zones.header}}</div><div>{{zones.footer}}</div>');
+        const result = (0, zone_consistency_1.validateZoneConsistency)(layout);
+        expect(result).toContain('Zone consistency validation failed');
+        expect(result).toContain('Zones defined in YAML but not used in template: sidebar');
+        expect(result).toContain('Zones used in template but not defined in YAML: footer');
+    });
+    it('should handle Handlebars each loops', () => {
+        const layout = createMockLayout({
+            items: { displayName: 'Items', description: 'Items zone' },
+        }, '<div>{{#each zones.items}}<p>{{this}}</p>{{/each}}</div>');
+        const result = (0, zone_consistency_1.validateZoneConsistency)(layout);
+        expect(result).toBeNull();
+    });
+    it('should handle Handlebars if conditions', () => {
+        const layout = createMockLayout({
+            optional: { displayName: 'Optional', description: 'Optional zone' },
+        }, '<div>{{#if zones.optional}}{{zones.optional}}{{/if}}</div>');
+        const result = (0, zone_consistency_1.validateZoneConsistency)(layout);
+        expect(result).toBeNull();
+    });
+    it('should handle complex Handlebars patterns', () => {
+        const layout = createMockLayout({
+            header: { displayName: 'Header', description: 'Header zone' },
+            content: { displayName: 'Content', description: 'Content zone' },
+            sidebar: { displayName: 'Sidebar', description: 'Sidebar zone' },
+        }, `
+        <div>{{zones.header}}</div>
+        <div>
+          {{#if zones.sidebar}}
+            <aside>{{zones.sidebar}}</aside>
+          {{/if}}
+          <main>{{zones.content}}</main>
+        </div>
+      `);
+        const result = (0, zone_consistency_1.validateZoneConsistency)(layout);
+        expect(result).toBeNull();
+    });
+    it('should handle empty zones object', () => {
+        const layout = createMockLayout({}, '<div>Static content only</div>');
+        const result = (0, zone_consistency_1.validateZoneConsistency)(layout);
+        expect(result).toBeNull();
+    });
+    it('should handle undefined zones property', () => {
+        const layout = {
+            name: 'test-layout',
+            displayName: 'Test Layout',
+            description: 'A test layout',
+            zones: undefined,
+            template: '<div>Static content only</div>',
+        };
+        const result = (0, zone_consistency_1.validateZoneConsistency)(layout);
+        expect(result).toBeNull();
+    });
+});

package/lib/page/templates/validation.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * @license
+ * Copyright (c) 2025, Squiz Australia Pty Ltd.
+ * All rights reserved.
+ */
+/**
+ * Validates a template file and returns detailed results
+ * @param content - The template to validate
+ * @returns An array of errors
+ */
+export declare function validateTemplateFile(content: string): string[];

package/lib/page/templates/validation.js

@@ -0,0 +1,30 @@
+"use strict";
+/*!
+ * @license
+ * Copyright (c) 2025, Squiz Australia Pty Ltd.
+ * All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTemplateFile = void 0;
+/**
+ * Validates a template file and returns detailed results
+ * @param content - The template to validate
+ * @returns An array of errors
+ */
+function validateTemplateFile(content) {
+    const errors = [];
+    // Check for top-level HTML structure tags that should not be in body content
+    const topLevelTags = [
+        { name: 'html', regex: /<html(\s|>)/gi },
+        { name: 'head', regex: /<head(\s|>)/gi },
+        { name: 'body', regex: /<body(\s|>)/gi },
+        { name: 'doctype', regex: /<!DOCTYPE[^>]*>/gi },
+    ];
+    for (const tag of topLevelTags) {
+        if (tag.regex.test(content)) {
+            errors.push(`Template should not contain top-level HTML structure tag: <${tag.name}>. Templates should only contain body content.`);
+        }
+    }
+    return errors;
+}
+exports.validateTemplateFile = validateTemplateFile;

package/lib/page/templates/validation.spec.d.ts

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

package/lib/page/templates/validation.spec.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validation_1 = require("./validation");
+describe('Handlebars Template Validation', () => {
+    describe('validateTemplateFile', () => {
+        it('should validate an empty template', () => {
+            const template = '';
+            const errors = (0, validation_1.validateTemplateFile)(template);
+            expect(errors).toHaveLength(0);
+        });
+        it('should validate a simple valid template', () => {
+            const template = '<div>{{zones.content}}</div>';
+            const errors = (0, validation_1.validateTemplateFile)(template);
+            expect(errors).toHaveLength(0);
+        });
+        it('should detect top-level HTML tags', () => {
+            const template = '<html><body><div>{{zones.content}}</div></body></html>';
+            const errors = (0, validation_1.validateTemplateFile)(template);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors).toEqual(expect.arrayContaining([
+                expect.stringContaining('Template should not contain top-level HTML structure tag: <html>'),
+                expect.stringContaining('Template should not contain top-level HTML structure tag: <body>'),
+            ]));
+        });
+        it('should detect DOCTYPE declarations', () => {
+            const template = '<!DOCTYPE html><div>{{zones.content}}</div>';
+            const errors = (0, validation_1.validateTemplateFile)(template);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors).toEqual(expect.arrayContaining([
+                expect.stringContaining('Template should not contain top-level HTML structure tag: <doctype>'),
+            ]));
+        });
+        it('should detect head tags', () => {
+            const template = '<head><title>Test</title></head><div>{{zones.content}}</div>';
+            const errors = (0, validation_1.validateTemplateFile)(template);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors).toEqual(expect.arrayContaining([
+                expect.stringContaining('Template should not contain top-level HTML structure tag: <head>'),
+            ]));
+        });
+        it('should allow body content elements', () => {
+            const template = `
+        <div class="layout">
+          <header>{{zones.header}}</header>
+          <main>{{zones.content}}</main>
+          <aside>{{zones.sidebar}}</aside>
+          <footer>{{zones.footer}}</footer>
+        </div>
+      `;
+            const errors = (0, validation_1.validateTemplateFile)(template);
+            expect(errors).toHaveLength(0);
+        });
+        it('should allow complex Handlebars expressions', () => {
+            const template = `
+        <div class="layout">
+          {{#if zones.header}}
+            <header>{{zones.header}}</header>
+          {{/if}}
+          <main>{{zones.content}}</main>
+          {{#each zones.sidebar}}
+            <aside>{{this}}</aside>
+          {{/each}}
+        </div>
+      `;
+            const errors = (0, validation_1.validateTemplateFile)(template);
+            expect(errors).toHaveLength(0);
+        });
+        it('should allow all valid HTML body elements', () => {
+            const template = `
+        <div>{{zones.content}}</div>
+        <p>{{zones.text}}</p>
+        <span>{{zones.inline}}</span>
+        <section>{{zones.section}}</section>
+        <article>{{zones.article}}</article>
+        <nav>{{zones.navigation}}</nav>
+        <header>{{zones.header}}</header>
+        <footer>{{zones.footer}}</footer>
+        <aside>{{zones.sidebar}}</aside>
+        <main>{{zones.main}}</main>
+        <h1>{{zones.title}}</h1>
+        <img src="{{zones.image}}" alt="{{zones.alt}}">
+        <a href="{{zones.link}}">{{zones.linkText}}</a>
+        <ul>{{#each zones.list}}<li>{{this}}</li>{{/each}}</ul>
+      `;
+            const errors = (0, validation_1.validateTemplateFile)(template);
+            expect(errors).toHaveLength(0);
+        });
+    });
+});

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

@@ -1,3 +1,8 @@
+/*!
+ * @license
+ * Copyright (c) 2025, Squiz Australia Pty Ltd.
+ * All rights reserved.
+ */
 import { z } from 'zod';
 export declare function loadLayoutDefinition(layoutFile: string): Promise<LayoutDefinition>;
 export declare function loadLayoutFromFile(layoutFile: string): Promise<InputLayoutDefinition>;

package/lib/page/utils/definitions.js

@@ -1,4 +1,9 @@
 "use strict";
+/*!
+ * @license
+ * Copyright (c) 2025, Squiz Australia Pty Ltd.
+ * All rights reserved.
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -44,10 +49,13 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LayoutDefinition = exports.InputLayoutDefinition = exports.BaseLayoutDefinition = exports.loadLayoutFromFile = exports.loadLayoutDefinition = void 0;
+// External
 const fs = __importStar(require("node:fs/promises"));
 const path = __importStar(require("node:path"));
 const zod_1 = require("zod");
 const yaml_1 = require("yaml");
+// Local
+const validation_1 = require("../templates/validation");
 function loadLayoutDefinition(layoutFile) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
@@ -83,12 +91,24 @@ function loadLayoutFromFile(layoutFile) {
     });
 }
 exports.loadLayoutFromFile = loadLayoutFromFile;
+/**
+ * Loads a template file from a file system
+ * @param layoutDirectory - The path to the layout directory
+ * @param templateFile - The path to the template file
+ * @returns The template
+ */
 function loadTemplate(layoutDirectory, templateFile) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            return yield fs.readFile(path.resolve(layoutDirectory, templateFile), {
+            const template = yield fs.readFile(path.resolve(layoutDirectory, templateFile), {
                 encoding: 'utf-8',
             });
+            // Validate the template
+            const validationErrors = yield (0, validation_1.validateTemplateFile)(template);
+            if (validationErrors.length > 0) {
+                throw new Error(validationErrors.join('\n'));
+            }
+            return template;
         }
         catch (e) {
             throw Error(`Failed loading template file "${templateFile}": ${e.message}`);

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

@@ -34,6 +34,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = __importStar(require("node:fs/promises"));
 const definitions_1 = require("./definitions");
+const validation_1 = require("../templates/validation");
 jest.mock('node:fs/promises');
 describe('loadLayoutDefinition', () => {
     const paintLayoutFileYaml = './some-dir/page-layout.yaml';
@@ -436,3 +437,64 @@ describe('LayoutDefinitionParse', () => {
         expect(layoutDefinition.zones.main.minNodes).toBe(0);
     });
 });
+describe('validateTemplateFile', () => {
+    describe('valid templates', () => {
+        it('should validate a simple valid template', () => __awaiter(void 0, void 0, void 0, function* () {
+            const template = '<div>{{zones.content}}</div>';
+            const errors = yield (0, validation_1.validateTemplateFile)(template);
+            expect(errors).toHaveLength(0);
+        }));
+        it('should validate a complex valid template', () => __awaiter(void 0, void 0, void 0, function* () {
+            const template = `
+        <div class="layout">
+          {{#if zones.header}}
+            <header>{{zones.header}}</header>
+          {{/if}}
+          <main>{{zones.content}}</main>
+          {{#each zones.sidebar}}
+            <aside>{{this}}</aside>
+          {{/each}}
+        </div>
+      `;
+            const errors = yield (0, validation_1.validateTemplateFile)(template);
+            expect(errors).toHaveLength(0);
+        }));
+        it('should validate template with options', () => __awaiter(void 0, void 0, void 0, function* () {
+            const template = '<div class="{{options.theme}}">{{zones.content}}</div>';
+            const errors = yield (0, validation_1.validateTemplateFile)(template);
+            expect(errors).toHaveLength(0);
+        }));
+        it('should allow empty template', () => __awaiter(void 0, void 0, void 0, function* () {
+            const template = '';
+            const errors = yield (0, validation_1.validateTemplateFile)(template);
+            expect(errors).toHaveLength(0);
+        }));
+    });
+    describe('invalid templates', () => {
+        it('should detect top-level HTML tags', () => __awaiter(void 0, void 0, void 0, function* () {
+            const template = '<html><body>{{zones.content}}</body></html>';
+            const errors = yield (0, validation_1.validateTemplateFile)(template);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors).toEqual(expect.arrayContaining([
+                expect.stringContaining('Template should not contain top-level HTML structure tag: <html>'),
+                expect.stringContaining('Template should not contain top-level HTML structure tag: <body>'),
+            ]));
+        }));
+        it('should detect DOCTYPE declarations', () => __awaiter(void 0, void 0, void 0, function* () {
+            const template = '<!DOCTYPE html><div>{{zones.content}}</div>';
+            const errors = yield (0, validation_1.validateTemplateFile)(template);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors).toEqual(expect.arrayContaining([
+                expect.stringContaining('Template should not contain top-level HTML structure tag: <doctype>'),
+            ]));
+        }));
+    });
+    describe('error handling', () => {
+        it('should handle null template gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Test with a null template
+            const template = null;
+            const errors = yield (0, validation_1.validateTemplateFile)(template);
+            expect(errors).toHaveLength(0);
+        }));
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/dxp-cli-next",
-  "version": "5.30.0-develop.1",
+  "version": "5.30.0-develop.3",
   "repository": {
     "url": "https://gitlab.squiz.net/dxp/dxp-cli-next"
   },