@squiz/dxp-cli-next 5.31.0-develop.3 → 5.31.0-develop.5

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

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const property_consistency_1 = require("./property-consistency");
+describe('validatePropertyConsistency', () => {
+    const createMockLayout = (layout) => (Object.assign({ name: 'test-layout', displayName: 'Test Layout', description: 'A test layout', zones: [], template: '' }, layout));
+    describe('new format (manifest.json)', () => {
+        it('should return null for valid property consistency', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    showHeader: {
+                        type: 'boolean',
+                        title: 'Show Header',
+                        description: 'Whether to show header',
+                    },
+                },
+                template: '<div>{{properties.title}}</div><div>{{#if properties.showHeader}}Header{{/if}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+        it('should return null when no template is provided', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+        it('should return null when layout has empty properties object', () => {
+            const layout = createMockLayout({
+                properties: {},
+                template: '<div>Static content only</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+        it('should return null when layout has undefined properties', () => {
+            const layout = createMockLayout({
+                template: '<div>Static content only</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+        it('should allow properties that are defined in the layout, but not used in template', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    unused: {
+                        type: 'string',
+                        title: 'Unused',
+                        description: 'Unused property',
+                    },
+                },
+                template: '<div>{{properties.title}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+        it('should detect properties used in template but not defined in layout', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '<div>{{properties.title}}</div><div>{{properties.undefined}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toContain('Property consistency validation failed');
+            expect(result).toContain('Properties used in template but not defined in layout definition: undefined');
+        });
+        it('should handle both unused and undefined properties', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    unused: {
+                        type: 'string',
+                        title: 'Unused',
+                        description: 'Unused property',
+                    },
+                },
+                template: '<div>{{properties.title}}</div><div>{{properties.undefined}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toContain('Property consistency validation failed');
+            expect(result).toContain('Properties used in template but not defined in layout definition: undefined');
+        });
+        it('should reject options usage in manifest.json format', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '<div>{{properties.title}}</div><div>{{options.invalid}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toContain('Property consistency validation failed');
+            expect(result).toContain('Options are not supported in the Handlebars template for a layout defined with "manifest.json". Please use properties instead.');
+        });
+        it('should handle complex Handlebars patterns', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    showHeader: {
+                        type: 'boolean',
+                        title: 'Show Header',
+                        description: 'Whether to show header',
+                    },
+                    theme: {
+                        type: 'string',
+                        title: 'Theme',
+                        description: 'Page theme',
+                    },
+                },
+                template: `
+          <div>{{properties.title}}</div>
+          <div>{{toLowerCase properties.title}}</div>
+          <div>
+            {{#if properties.showHeader}}
+              <header>Header</header>
+            {{/if}}
+            {{#ifEq "dark" properties.theme}}
+              <div class="dark">Dark theme</div>
+            {{/ifEq}}
+          </div>
+        `,
+            });
+            const manifestResult = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(manifestResult).toBeNull();
+            const pageLayoutResult = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/page-layout.yaml');
+            expect(pageLayoutResult).toContain('Option consistency validation failed');
+            expect(pageLayoutResult).toContain('Properties are only allowed in the Handlebars template for a layout defined with "manifest.json". Please use options instead.');
+        });
+    });
+    describe('old format (page-layout.yaml)', () => {
+        it('should return null for valid option consistency', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    showHeader: {
+                        type: 'boolean',
+                        title: 'Show Header',
+                        description: 'Whether to show header',
+                    },
+                },
+                template: '<div>{{options.title}}</div><div>{{#if options.showHeader}}Header{{/if}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/page-layout.yaml');
+            expect(result).toBeNull();
+        });
+        it('should allow options that are defined in the layout, but not used in template', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    unused: {
+                        type: 'string',
+                        title: 'Unused',
+                        description: 'Unused option',
+                    },
+                },
+                template: '<div>{{options.title}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/page-layout.yaml');
+            expect(result).toBeNull();
+        });
+        it('should detect options used in template but not defined in layout', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '<div>{{options.title}}</div><div>{{options.undefined}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/page-layout.yaml');
+            expect(result).toContain('Option consistency validation failed');
+            expect(result).toContain('Options used in template but not defined in layout definition: undefined');
+        });
+        it('should reject properties usage in old format', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '<div>{{options.title}}</div><div>{{properties.invalid}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/page-layout.yaml');
+            expect(result).toContain('Option consistency validation failed');
+            expect(result).toContain('Properties are only allowed in the Handlebars template for a layout defined with "manifest.json". Please use options instead.');
+        });
+        it('should handle complex Handlebars patterns', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    showHeader: {
+                        type: 'boolean',
+                        title: 'Show Header',
+                        description: 'Whether to show header',
+                    },
+                    theme: {
+                        type: 'string',
+                        title: 'Theme',
+                        description: 'Page theme',
+                    },
+                },
+                template: `
+          <div>{{options.title}}</div>
+          <div>{{toLowerCase options.title}}</div>
+          <div>
+            {{#if options.showHeader}}
+              <header>Header</header>
+            {{/if}}
+            {{#ifEq "dark" options.theme}}
+              <div class="dark">Dark theme</div>
+            {{/ifEq}}
+          </div>
+        `,
+            });
+            const pageLayoutResult = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/page-layout.yaml');
+            expect(pageLayoutResult).toBeNull();
+            const manifestResult = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(manifestResult).toContain('Property consistency validation failed');
+            expect(manifestResult).toContain('Options are not supported in the Handlebars template for a layout defined with "manifest.json". Please use properties instead.');
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle multiple property references in same template', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                },
+                template: '<div>{{properties.title}}</div><div>{{properties.title}}</div><div>{{#if properties.title}}Yes{{/if}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+        it('should handle property names with different casing', () => {
+            const layout = createMockLayout({
+                properties: {
+                    title: {
+                        type: 'string',
+                        title: 'Title',
+                        description: 'Page title',
+                    },
+                    Title: {
+                        type: 'string',
+                        title: 'Title Capitalized',
+                        description: 'Title with capital T',
+                    },
+                },
+                template: '<div>{{properties.title}}</div><div>{{properties.Title}}</div>',
+            });
+            const result = (0, property_consistency_1.validatePropertyConsistency)(layout, '/path/to/manifest.json');
+            expect(result).toBeNull();
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+import { Logger } from '@squiz/dx-logger-lib';
+export declare function validateLayoutFormat(logger: Logger, layoutFile?: string): void;

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

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLayoutFormat = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const definitions_1 = require("../../utils/definitions");
+function validateLayoutFormat(logger, layoutFile) {
+    // Warn that the default layout file has been changed
+    if (!layoutFile) {
+        logger.warn(`⚠️  DEFAULT CONFIG FILE: "${definitions_1.LAYOUT_MANIFEST_FILE}" has replaced "page-layout.yaml" as the default config file. ` +
+            `Please migrate to "${definitions_1.LAYOUT_MANIFEST_FILE}" using the new layout definition format. ` +
+            'Support for "page-layout.yaml" and any other file format will be removed in a future version. ');
+        return;
+    }
+    // Warn that any file other than manifest.json is deprecated
+    const fileName = node_path_1.default.basename(layoutFile);
+    if (fileName !== definitions_1.LAYOUT_MANIFEST_FILE) {
+        logger.warn(`⚠️  DEPRECATED: The file name "${fileName}" is deprecated. ` +
+            `Please migrate to "${definitions_1.LAYOUT_MANIFEST_FILE}" using the new layout definition format. ` +
+            'Support for any other file format will be removed in a future version. ');
+    }
+}
+exports.validateLayoutFormat = validateLayoutFormat;

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

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

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validateLayoutFormat_1 = require("./validateLayoutFormat");
+const definitions_1 = require("../../utils/definitions");
+describe('validateLayoutFormat', () => {
+    let mockLogger;
+    beforeEach(() => {
+        mockLogger = {
+            warn: jest.fn(),
+        };
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should not log a warning when file is manifest.json', () => {
+        const layoutFile = `/some/path/${definitions_1.LAYOUT_MANIFEST_FILE}`;
+        (0, validateLayoutFormat_1.validateLayoutFormat)(mockLogger, layoutFile);
+        expect(mockLogger.warn).not.toHaveBeenCalled();
+    });
+    it('should log a deprecation warning when file is not manifest.json', () => {
+        const layoutFile = '/some/path/page-layout.yaml';
+        (0, validateLayoutFormat_1.validateLayoutFormat)(mockLogger, layoutFile);
+        expect(mockLogger.warn).toHaveBeenCalledTimes(1);
+        expect(mockLogger.warn).toHaveBeenCalledWith('⚠️  DEPRECATED: The file name "page-layout.yaml" is deprecated. ' +
+            `Please migrate to "${definitions_1.LAYOUT_MANIFEST_FILE}" using the new layout definition format. ` +
+            'Support for any other file format will be removed in a future version. ');
+    });
+    it('should extract filename correctly from full path', () => {
+        const layoutFile = '/very/deep/nested/path/to/layout/page-layout.yaml';
+        (0, validateLayoutFormat_1.validateLayoutFormat)(mockLogger, layoutFile);
+        expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('"page-layout.yaml"'));
+    });
+    it('should log a default config file warning when file is not provided', () => {
+        (0, validateLayoutFormat_1.validateLayoutFormat)(mockLogger);
+        expect(mockLogger.warn).toHaveBeenCalledTimes(1);
+        expect(mockLogger.warn).toHaveBeenCalledWith('⚠️  DEFAULT CONFIG FILE: "manifest.json" has replaced "page-layout.yaml" as the default config file. ' +
+            `Please migrate to "${definitions_1.LAYOUT_MANIFEST_FILE}" using the new layout definition format. ` +
+            'Support for "page-layout.yaml" and any other file format will be removed in a future version. ');
+    });
+});

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

@@ -1,6 +1,6 @@
 import { LayoutDefinition } from '../../utils/definitions';
 /**
- * Validates that zones defined in YAML match zones used in the Handlebars template
+ * Validates that zones defined in layout definition 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
  */

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

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateZoneConsistency = void 0;
 /**
- * Validates that zones defined in YAML match zones used in the Handlebars template
+ * Validates that zones defined in layout definition 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 || {});
+    var _a, _b;
+    const layoutZones = (_b = (_a = layout.zones) === null || _a === void 0 ? void 0 : _a.map(zone => zone.key)) !== null && _b !== void 0 ? _b : [];
     const template = layout.template;
     // If no template is provided, skip validation
     if (!template) {
@@ -24,19 +25,19 @@ function validateZoneConsistency(layout) {
     }
     // 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));
+    // Find zones defined in layout definition but not used in template
+    const unusedLayoutZones = layoutZones.filter(zone => !templateZones.has(zone));
+    // Find zones used in template but not defined in layout definition
+    const undefinedTemplateZones = templateZoneArray.filter(zone => !layoutZones.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(', ')}`);
+    if (unusedLayoutZones.length > 0) {
+        errors.push(`Zones defined in layout definition but not used in template: ${unusedLayoutZones.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(', ')}`);
+        errors.push(`Zones used in template but not defined in layout definition: ${undefinedTemplateZones.join(', ')}`);
     }
     // If there are errors, return the errors
     if (errors.length > 0) {

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

@@ -10,67 +10,65 @@ describe('validateZoneConsistency', () => {
         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 layout = createMockLayout([
+            { key: 'header', displayName: 'Header', description: 'Header zone' },
+            { key: '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 layout = createMockLayout([{ key: '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 layout = createMockLayout([
+            { key: 'header', displayName: 'Header', description: 'Header zone' },
+            { key: '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');
+        expect(result).toContain('Zones defined in layout definition 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 layout = createMockLayout([{ key: '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');
+        expect(result).toContain('Zones used in template but not defined in layout definition: 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 layout = createMockLayout([
+            { key: 'header', displayName: 'Header', description: 'Header zone' },
+            { key: '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');
+        expect(result).toContain('Zones defined in layout definition but not used in template: sidebar');
+        expect(result).toContain('Zones used in template but not defined in layout definition: 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 layout = createMockLayout([{ key: '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 layout = createMockLayout([
+            {
+                key: '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' },
-        }, `
+        const layout = createMockLayout([
+            { key: 'header', displayName: 'Header', description: 'Header zone' },
+            { key: 'content', displayName: 'Content', description: 'Content zone' },
+            { key: 'sidebar', displayName: 'Sidebar', description: 'Sidebar zone' },
+        ], `
         <div>{{zones.header}}</div>
         <div>
           {{#if zones.sidebar}}
@@ -83,7 +81,7 @@ describe('validateZoneConsistency', () => {
         expect(result).toBeNull();
     });
     it('should handle empty zones object', () => {
-        const layout = createMockLayout({}, '<div>Static content only</div>');
+        const layout = createMockLayout([], '<div>Static content only</div>');
         const result = (0, zone_consistency_1.validateZoneConsistency)(layout);
         expect(result).toBeNull();
     });