@squiz/dxp-cli-next 5.30.0-develop.2 → 5.30.0-develop.4

package/lib/cdp/instance/activate/activate.js

@@ -37,6 +37,9 @@ const createActivateCommand = () => {
             write(chalk_1.default.red(str));
         },
     })
+        .addOption(new commander_1.Option('-r, --region <string>', 'Region for your cdp instance to be activated e.g. au')
+        .choices(['au', 'us', 'uk'])
+        .default(''))
         .action((options) => __awaiter(void 0, void 0, void 0, function* () {
         yield (0, utils_1.throwErrorIfNotLoggedIn)(activateCommand);
         console.log('');
@@ -47,10 +50,22 @@ const createActivateCommand = () => {
                     return status < 400 || status === 404;
                 },
             });
-            const scvDeployBaseUrl = yield (0, utils_1.buildDXPUrl)(constants_1.SCV_DEPLOY_SERVICE_NAME);
-            const apiUrl = `${scvDeployBaseUrl.dxpUrl}/${scvDeployBaseUrl.tenant}`;
+            const scvDeployBaseUrl = yield (0, utils_1.buildDXPUrl)(constants_1.SCV_DEPLOY_SERVICE_NAME, '', '', options.region);
+            let apiUrl = '';
+            const tenant = scvDeployBaseUrl.tenant;
+            const hasRegion = options.region !== '';
+            // If the region is provided, use the region specific URL
+            // Otherwise, we utilize service to automatically retrieve the region for us
+            if (hasRegion) {
+                apiUrl = `${scvDeployBaseUrl.dxpUrl}/${tenant}`;
+            }
+            else {
+                apiUrl = `${scvDeployBaseUrl.dxpUrl}`;
+            }
             const getDeployResponse = (yield apiService.client
-                .get(apiUrl)
+                .get(apiUrl, {
+                headers: Object.assign({ 'Content-Type': 'application/json' }, (!hasRegion && { 'x-dxp-tenant': tenant })),
+            })
                 .catch((err) => {
                 (0, utils_1.logDebug)(`RAW ERROR: ${JSON.stringify(err)}`);
                 if (err.response && err.response.status != 404) {
@@ -62,7 +77,9 @@ const createActivateCommand = () => {
             }
             (0, utils_1.logDebug)(`PUT ${apiUrl}`);
             const activateInstanceAndDeploySchemaResponse = (yield apiService.client
-                .put(apiUrl)
+                .put(apiUrl, {
+                headers: Object.assign({ 'Content-Type': 'application/json' }, (!hasRegion && { 'x-dxp-tenant': tenant })),
+            })
                 .catch((err) => {
                 (0, utils_1.logDebug)(`RAW ERROR: ${JSON.stringify(err)}`);
                 if (err.response) {

package/lib/cdp/instance/activate/activate.spec.js

@@ -42,7 +42,7 @@ const activate = __importStar(require("./activate"));
 const utils = __importStar(require("../../utils"));
 const axios_1 = __importDefault(require("axios"));
 jest.mock('axios');
-const mockDomainWithPath = 'http://localhost:9999/__dxp/us/scv-deploy/myTenant';
+const mockDomainWithPath = 'http://localhost:9999/__dxp/service/scv-deploy/myTenant';
 function createMockArgs() {
     return ['node', 'dxp-cli', 'cdp', 'instance', 'activate'];
 }
@@ -65,103 +65,216 @@ describe('cdpInstanceCommand', () => {
     afterEach(() => {
         jest.clearAllMocks();
     });
-    it('should throw error when tenant exists', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockedAxiosInstance = {
-            get: jest.fn().mockResolvedValue({ status: 200 }),
-            interceptors: {
-                request: { use: jest.fn() },
-                response: { use: jest.fn() },
-            },
-        };
-        axios_1.default.create.mockReturnValue(mockedAxiosInstance);
-        jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
-            dxpUrl: `${mockDomain}/__dxp/us/scv-deploy`,
-            tenant: mockTenant,
-        });
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
-        expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
-        const program = (0, activate_1.default)();
-        yield program.parseAsync(createMockArgs());
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining(activate_1.errorMessage));
-    }));
-    it('deploys a default schema and activate an instance', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
-            dxpUrl: `${mockDomain}/__dxp/us/scv-deploy`,
-            tenant: mockTenant,
-        });
-        jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
-        const mockedAxiosInstance = {
-            get: jest.fn().mockResolvedValue({ status: 404 }),
-            put: jest
-                .fn()
-                .mockResolvedValue({ status: 200, data: { message: 'Success' } }),
-            interceptors: {
-                request: { use: jest.fn() },
-                response: { use: jest.fn() },
-            },
-        };
-        axios_1.default.create.mockReturnValue(mockedAxiosInstance);
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
-        expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
-        const program = (0, activate_1.default)();
-        yield program.parseAsync(createMockArgs());
-        expect(mockedAxiosInstance.put).toHaveBeenCalledWith(`${mockDomain}${mockPath}`);
-        // Note the output from the spinner doesn't seem to appear here but this still tests that it
-        // ran without displaying an error.
-        expect(logSpy).toHaveBeenNthCalledWith(1, '');
-        expect(logSpy).toHaveBeenNthCalledWith(2, '');
-        expect(logSpy).toHaveBeenNthCalledWith(3, 'Your Schema has been deployed and instance has been activated.');
-        expect(logSpy).toHaveBeenNthCalledWith(4, '');
-        expect(errorSpy).not.toHaveBeenCalled();
-    }));
-    it('should throw error when trying to activate an instance currently', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
-            dxpUrl: `${mockDomain}/__dxp/us/scv-deploy`,
-            tenant: mockTenant,
-        });
-        jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
-        const mockedAxios = axios_1.default;
-        //GET request (404)
-        mockedAxios.get.mockResolvedValueOnce({
-            status: 404,
-            data: { status: deploy_const_1.CDP_DEPLOY_STATUS_ERROR },
-        });
-        // PUT request (409)
-        mockedAxios.put.mockResolvedValueOnce({
-            status: 409,
-            data: {
-                tenantid: 'myTenant',
-                version: 'unknown',
-                stack: 'stackName',
-                status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYING,
-            },
-        });
-        axios_1.default.create.mockReturnValue(mockedAxios);
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
-        expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
-        const program = (0, activate_1.default)();
-        yield program.parseAsync(createMockArgs());
-        expect(mockedAxios.put).toHaveBeenCalledWith(`${mockDomain}${mockPath}`);
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Currently activating instance. Please try again later.'));
-    }));
-    it('should throw error when get tenant returns 403', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockedAxiosInstance = {
-            get: jest.fn().mockRejectedValue({
-                response: { status: 403, data: {} },
-            }),
-            interceptors: {
-                request: { use: jest.fn() },
-                response: { use: jest.fn() },
-            },
-        };
-        axios_1.default.create.mockReturnValue(mockedAxiosInstance);
-        jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
-            dxpUrl: `${mockDomain}/__dxp/us/scv-deploy`,
-            tenant: mockTenant,
-        });
-        const handleActivateErrorSpy = jest.spyOn(activate, 'handleActivateError');
-        const program = (0, activate_1.default)();
-        yield program.parseAsync(createMockArgs());
-        expect(handleActivateErrorSpy).toHaveBeenCalledWith(403, {});
-    }));
+    describe('when region is provided', () => {
+        it.each(['au', 'us', 'uk'])('should throw error when tenant exists for %s region', (region) => __awaiter(void 0, void 0, void 0, function* () {
+            const mockedAxiosInstance = {
+                get: jest.fn().mockResolvedValue({ status: 200 }),
+                interceptors: {
+                    request: { use: jest.fn() },
+                    response: { use: jest.fn() },
+                },
+            };
+            axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/${region}/scv-deploy`,
+                tenant: mockTenant,
+            });
+            const program = (0, activate_1.default)();
+            yield program.parseAsync((0, utils_1.createMockActivateArgs)(region));
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining(activate_1.errorMessage));
+        }));
+        it.each(['au', 'us', 'uk'])('deploys a default schema and activate an instance for %s region', (region) => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/${region}/scv-deploy`,
+                tenant: mockTenant,
+            });
+            jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
+            const mockedAxiosInstance = {
+                get: jest.fn().mockResolvedValue({ status: 404 }),
+                put: jest
+                    .fn()
+                    .mockResolvedValue({ status: 200, data: { message: 'Success' } }),
+                interceptors: {
+                    request: { use: jest.fn() },
+                    response: { use: jest.fn() },
+                },
+            };
+            axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+            const program = (0, activate_1.default)();
+            yield program.parseAsync((0, utils_1.createMockActivateArgs)(region));
+            expect(mockedAxiosInstance.put).toHaveBeenCalledWith(`http://localhost:9999/__dxp/${region}/scv-deploy/${mockTenant}`, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            expect(logSpy).toHaveBeenNthCalledWith(1, '');
+            expect(logSpy).toHaveBeenNthCalledWith(2, '');
+            expect(logSpy).toHaveBeenNthCalledWith(3, 'Your Schema has been deployed and instance has been activated.');
+            expect(logSpy).toHaveBeenNthCalledWith(4, '');
+            expect(errorSpy).not.toHaveBeenCalled();
+        }));
+        it.each(['au', 'us', 'uk'])('should throw error when trying to activate an instance currently for %s region', (region) => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/${region}/scv-deploy`,
+                tenant: mockTenant,
+            });
+            jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
+            const mockedAxios = axios_1.default;
+            //GET request (404)
+            mockedAxios.get.mockResolvedValueOnce({
+                status: 404,
+                data: { status: deploy_const_1.CDP_DEPLOY_STATUS_ERROR },
+            });
+            // PUT request (409)
+            mockedAxios.put.mockResolvedValueOnce({
+                status: 409,
+                data: {
+                    tenantid: 'myTenant',
+                    version: 'unknown',
+                    stack: 'stackName',
+                    status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYING,
+                },
+            });
+            axios_1.default.create.mockReturnValue(mockedAxios);
+            const program = (0, activate_1.default)();
+            yield program.parseAsync((0, utils_1.createMockActivateArgs)(region));
+            expect(mockedAxios.put).toHaveBeenCalledWith(`http://localhost:9999/__dxp/${region}/scv-deploy/${mockTenant}`, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Currently activating instance. Please try again later.'));
+        }));
+        it.each(['au', 'us', 'uk'])('should throw error when get tenant returns 403 for %s region', (region) => __awaiter(void 0, void 0, void 0, function* () {
+            const mockedAxiosInstance = {
+                get: jest.fn().mockRejectedValue({
+                    response: { status: 403, data: {} },
+                }),
+                interceptors: {
+                    request: { use: jest.fn() },
+                    response: { use: jest.fn() },
+                },
+            };
+            axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/${region}/scv-deploy`,
+                tenant: mockTenant,
+            });
+            const handleActivateErrorSpy = jest.spyOn(activate, 'handleActivateError');
+            const program = (0, activate_1.default)();
+            yield program.parseAsync((0, utils_1.createMockActivateArgs)(region));
+            expect(handleActivateErrorSpy).toHaveBeenCalledWith(403, {});
+        }));
+    });
+    describe('when region is not provided', () => {
+        it('should throw error when tenant exists', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockedAxiosInstance = {
+                get: jest.fn().mockResolvedValue({ status: 200 }),
+                interceptors: {
+                    request: { use: jest.fn() },
+                    response: { use: jest.fn() },
+                },
+            };
+            axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/service/scv-deploy`,
+                tenant: mockTenant,
+            });
+            const mockPath = (0, utils_1.createMockUrl)(mockTenant);
+            expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
+            const program = (0, activate_1.default)();
+            yield program.parseAsync(createMockArgs());
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining(activate_1.errorMessage));
+        }));
+        it('deploys a default schema and activate an instance', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/service/scv-deploy`,
+                tenant: mockTenant,
+            });
+            jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
+            const mockedAxiosInstance = {
+                get: jest.fn().mockResolvedValue({ status: 404 }),
+                put: jest
+                    .fn()
+                    .mockResolvedValue({ status: 200, data: { message: 'Success' } }),
+                interceptors: {
+                    request: { use: jest.fn() },
+                    response: { use: jest.fn() },
+                },
+            };
+            axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+            const mockPath = (0, utils_1.createMockUrl)(mockTenant);
+            expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
+            const program = (0, activate_1.default)();
+            yield program.parseAsync(createMockArgs());
+            expect(mockedAxiosInstance.put).toHaveBeenCalledWith('http://localhost:9999/__dxp/service/scv-deploy', {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-dxp-tenant': 'myTenant',
+                },
+            });
+            // Note the output from the spinner doesn't seem to appear here but this still tests that it
+            // ran without displaying an error.
+            expect(logSpy).toHaveBeenNthCalledWith(1, '');
+            expect(logSpy).toHaveBeenNthCalledWith(2, '');
+            expect(logSpy).toHaveBeenNthCalledWith(3, 'Your Schema has been deployed and instance has been activated.');
+            expect(logSpy).toHaveBeenNthCalledWith(4, '');
+            expect(errorSpy).not.toHaveBeenCalled();
+        }));
+        it('should throw error when trying to activate an instance currently', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/service/scv-deploy`,
+                tenant: mockTenant,
+            });
+            jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
+            const mockedAxios = axios_1.default;
+            //GET request (404)
+            mockedAxios.get.mockResolvedValueOnce({
+                status: 404,
+                data: { status: deploy_const_1.CDP_DEPLOY_STATUS_ERROR },
+            });
+            // PUT request (409)
+            mockedAxios.put.mockResolvedValueOnce({
+                status: 409,
+                data: {
+                    tenantid: 'myTenant',
+                    version: 'unknown',
+                    stack: 'stackName',
+                    status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYING,
+                },
+            });
+            axios_1.default.create.mockReturnValue(mockedAxios);
+            const mockPath = (0, utils_1.createMockUrl)(mockTenant);
+            expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
+            const program = (0, activate_1.default)();
+            yield program.parseAsync(createMockArgs());
+            expect(mockedAxios.put).toHaveBeenCalledWith('http://localhost:9999/__dxp/service/scv-deploy', {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-dxp-tenant': 'myTenant',
+                },
+            });
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Currently activating instance. Please try again later.'));
+        }));
+        it('should throw error when get tenant returns 403', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockedAxiosInstance = {
+                get: jest.fn().mockRejectedValue({
+                    response: { status: 403, data: {} },
+                }),
+                interceptors: {
+                    request: { use: jest.fn() },
+                    response: { use: jest.fn() },
+                },
+            };
+            axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/service/scv-deploy`,
+                tenant: mockTenant,
+            });
+            const handleActivateErrorSpy = jest.spyOn(activate, 'handleActivateError');
+            const program = (0, activate_1.default)();
+            yield program.parseAsync(createMockArgs());
+            expect(handleActivateErrorSpy).toHaveBeenCalledWith(403, {});
+        }));
+    });
 });

package/lib/cdp/schema/deploy/deploy.spec.js

@@ -60,7 +60,7 @@ describe('cdpSchemaCommand', () => {
         jest.clearAllMocks(); // Clear all spies
     });
     it('correctly handles command arguments', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
+        const mockPath = (0, utils_1.createMockUrl)(mockTenant, mockRegion);
         (0, nock_1.default)(mockDomain)
             .put(mockPath, require(path_1.default.resolve(process.cwd(), './src/__tests__/cdp/scv/schema.json')))
             .reply(200, {
@@ -81,7 +81,7 @@ describe('cdpSchemaCommand', () => {
     }));
     it('presents a formatted invalid schema message', () => __awaiter(void 0, void 0, void 0, function* () {
         const schemaFileContent = require(path_1.default.resolve(process.cwd(), mockFilePath));
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
+        const mockPath = (0, utils_1.createMockUrl)(mockTenant, mockRegion);
         expect(`${mockDomain}${mockPath}`).toEqual('http://localhost:9999/__dxp/us/scv-deploy/myTenant');
         (0, nock_1.default)(mockDomain)
             .get(mockPath)
@@ -110,7 +110,7 @@ describe('cdpSchemaCommand', () => {
     }));
     it('deploys a schema', () => __awaiter(void 0, void 0, void 0, function* () {
         const schemaFileContent = require(path_1.default.resolve(process.cwd(), mockFilePath));
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
+        const mockPath = (0, utils_1.createMockUrl)(mockTenant, mockRegion);
         expect(`${mockDomain}${mockPath}`).toEqual('http://localhost:9999/__dxp/us/scv-deploy/myTenant');
         (0, nock_1.default)(mockDomain)
             .get(mockPath)

package/lib/cdp/utils.d.ts

@@ -14,7 +14,8 @@ export declare function buildDXPUrl(serviceName: string, tenantID?: string, over
     tenant: string | undefined;
 }>;
 export declare function handleCommandError(error: Error): void;
-export declare function createMockUrl(region: string, path: string): string;
+export declare function createMockUrl(path: string, region?: string): string;
+export declare function createMockActivateArgs(region: string): Array<string>;
 /**
  * Poll the schema to be deployed.
  */

package/lib/cdp/utils.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pollForDeployedSchema = exports.createMockUrl = exports.handleCommandError = exports.buildDXPUrl = exports.throwErrorIfNotLoggedIn = exports.logDebug = void 0;
+exports.pollForDeployedSchema = exports.createMockActivateArgs = exports.createMockUrl = exports.handleCommandError = exports.buildDXPUrl = exports.throwErrorIfNotLoggedIn = exports.logDebug = void 0;
 const ApplicationStore_1 = require("../ApplicationStore");
 const chalk_1 = __importDefault(require("chalk"));
 const ApplicationConfig_1 = require("../ApplicationConfig");
@@ -43,14 +43,14 @@ function buildDXPUrl(serviceName, tenantID, override, region) {
             const existingConfig = yield (0, ApplicationConfig_1.fetchApplicationConfig)(tenantID);
             logDebug(`existingConfig: ${JSON.stringify(existingConfig)}`);
             return {
-                dxpUrl: `${existingConfig.baseUrl}/__dxp/${region || existingConfig.region}/${serviceName}`,
+                dxpUrl: `${existingConfig.baseUrl}/__dxp/${region || 'service'}/${serviceName}`,
                 tenant: existingConfig.tenant,
             };
         }
         else {
             logDebug(`Using override URL: ${override}`);
             return {
-                dxpUrl: `${override}/__dxp/${region || 'au'}/${serviceName}`,
+                dxpUrl: `${override}/__dxp/${region || 'service'}/${serviceName}`,
                 tenant: tenantID,
             };
         }
@@ -82,10 +82,14 @@ function handleCommandError(error) {
     }
 }
 exports.handleCommandError = handleCommandError;
-function createMockUrl(region, path) {
-    return `/__dxp/${region}/scv-deploy/${path}`;
+function createMockUrl(path, region) {
+    return `/__dxp/${region || 'service'}/scv-deploy/${path}`;
 }
 exports.createMockUrl = createMockUrl;
+function createMockActivateArgs(region) {
+    return ['node', 'dxp-cli', 'cdp', 'instance', 'activate', '--region', region];
+}
+exports.createMockActivateArgs = createMockActivateArgs;
 /**
  * Poll the schema to be deployed.
  */

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',
@@ -52,7 +53,7 @@ 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);
                 }
@@ -119,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/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.2",
+  "version": "5.30.0-develop.4",
   "repository": {
     "url": "https://gitlab.squiz.net/dxp/dxp-cli-next"
   },