Sync from monorepo

Template version: 1.1.0-dev

Uses bundled workspace packages (not yet on NPM)

Synced by: alafemina_sfemu

Monorepo SHA: efdee117b21a09a2e49a863d908d8d8a790cf4f8

Latest change: efdee117b - Merge pull request #1901 from commerce-emu/W-22727076-validate-uitarget-ids

Author: alafemina_sfemu

packages/storefront-next-dev/dist/index.d.ts.map

@@ -16,7 +16,7 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { join } from 'path';
 import fs from 'fs-extra';
-import { buildTargetRegistry, transformTargets } from './target-utils';
+import { buildTargetRegistry, transformTargets, collectUITargetIds, validateTargetRegistry } from './target-utils';
 import { logger } from '../utils/logger';
 
 describe('target-utils', () => {
@@ -630,4 +630,182 @@ describe('target-utils', () => {
             expect(result).not.toContain('UITargetProviders');
         });
     });
+
+    describe('collectUITargetIds', () => {
+        const testDir = join(__dirname, '__test-collect-targets__');
+
+        beforeEach(() => {
+            fs.ensureDirSync(testDir);
+        });
+
+        afterEach(() => {
+            fs.removeSync(testDir);
+        });
+
+        it('should collect targetIds from tsx files', () => {
+            fs.ensureDirSync(join(testDir, 'components'));
+            fs.writeFileSync(
+                join(testDir, 'components', 'page.tsx'),
+                `<UITarget targetId="sfcc.header.before.cart" />\n<UITarget targetId="sfcc.footer.start" />`
+            );
+
+            const ids = collectUITargetIds(testDir);
+            expect(ids).toContain('sfcc.header.before.cart');
+            expect(ids).toContain('sfcc.footer.start');
+            expect(ids.size).toBe(2);
+        });
+
+        it('should exclude the extensions directory', () => {
+            fs.ensureDirSync(join(testDir, 'extensions', 'my-ext'));
+            fs.writeFileSync(
+                join(testDir, 'extensions', 'my-ext', 'comp.tsx'),
+                `<UITarget targetId="should.not.be.found" />`
+            );
+            fs.ensureDirSync(join(testDir, 'components'));
+            fs.writeFileSync(join(testDir, 'components', 'page.tsx'), `<UITarget targetId="valid.target" />`);
+
+            const ids = collectUITargetIds(testDir);
+            expect(ids).not.toContain('should.not.be.found');
+            expect(ids).toContain('valid.target');
+        });
+
+        it('should exclude ui-target-dev-mode and ui-target-smoke-test directories', () => {
+            fs.ensureDirSync(join(testDir, 'ui-target-dev-mode'));
+            fs.writeFileSync(
+                join(testDir, 'ui-target-dev-mode', 'tool.tsx'),
+                `<UITarget targetId="dev.only.target" />`
+            );
+            fs.ensureDirSync(join(testDir, 'ui-target-smoke-test'));
+            fs.writeFileSync(
+                join(testDir, 'ui-target-smoke-test', 'test.tsx'),
+                `<UITarget targetId="smoke.test.target" />`
+            );
+
+            const ids = collectUITargetIds(testDir);
+            expect(ids).not.toContain('dev.only.target');
+            expect(ids).not.toContain('smoke.test.target');
+        });
+
+        it('should return empty set when no targets found', () => {
+            fs.writeFileSync(join(testDir, 'page.tsx'), `export default function Page() { return <div />; }`);
+
+            const ids = collectUITargetIds(testDir);
+            expect(ids.size).toBe(0);
+        });
+
+        it('should match single-quoted targetId attributes', () => {
+            fs.ensureDirSync(join(testDir, 'components'));
+            fs.writeFileSync(
+                join(testDir, 'components', 'page.tsx'),
+                `<UITarget targetId='sfcc.header.single.quote' />`
+            );
+
+            const ids = collectUITargetIds(testDir);
+            expect(ids).toContain('sfcc.header.single.quote');
+        });
+
+        it('should not match targetId on non-UITarget components', () => {
+            fs.ensureDirSync(join(testDir, 'components'));
+            fs.writeFileSync(
+                join(testDir, 'components', 'page.tsx'),
+                `<SomeOther targetId="not.a.real.target" />\n<UITarget targetId="real.target" />`
+            );
+
+            const ids = collectUITargetIds(testDir);
+            expect(ids).not.toContain('not.a.real.target');
+            expect(ids).toContain('real.target');
+            expect(ids.size).toBe(1);
+        });
+
+        it('should exclude test files', () => {
+            fs.ensureDirSync(join(testDir, 'components'));
+            fs.writeFileSync(join(testDir, 'components', 'page.tsx'), `<UITarget targetId="real.target" />`);
+            fs.writeFileSync(join(testDir, 'components', 'page.test.tsx'), `<UITarget targetId="test.only.target" />`);
+
+            const ids = collectUITargetIds(testDir);
+            expect(ids).toContain('real.target');
+            expect(ids).not.toContain('test.only.target');
+            expect(ids.size).toBe(1);
+        });
+    });
+
+    describe('validateTargetRegistry', () => {
+        it('should return empty array when all targetIds are declared', () => {
+            const registry = {
+                'sfcc.header.before.cart': [
+                    {
+                        targetId: 'sfcc.header.before.cart',
+                        path: 'extensions/foo/comp.tsx',
+                        namespace: 'Foo',
+                        componentName: 'Foo_Comp',
+                        order: 0,
+                    },
+                ],
+            };
+            const declared = new Set(['sfcc.header.before.cart', 'sfcc.footer.start']);
+
+            const orphaned = validateTargetRegistry(registry, declared);
+            expect(orphaned).toHaveLength(0);
+        });
+
+        it('should return orphaned entries for undeclared targetIds', () => {
+            const registry = {
+                'sfcc.header.before.cart': [
+                    {
+                        targetId: 'sfcc.header.before.cart',
+                        path: 'extensions/foo/comp.tsx',
+                        namespace: 'Foo',
+                        componentName: 'Foo_Comp',
+                        order: 0,
+                    },
+                ],
+                'sfcc.nonexistent.target': [
+                    {
+                        targetId: 'sfcc.nonexistent.target',
+                        path: 'extensions/bar/widget.tsx',
+                        namespace: 'Bar',
+                        componentName: 'Bar_Widget',
+                        order: 0,
+                    },
+                ],
+            };
+            const declared = new Set(['sfcc.header.before.cart']);
+
+            const orphaned = validateTargetRegistry(registry, declared);
+            expect(orphaned).toHaveLength(1);
+            expect(orphaned[0].targetId).toBe('sfcc.nonexistent.target');
+            expect(orphaned[0].extension).toBe('Bar');
+            expect(orphaned[0].componentPath).toBe('extensions/bar/widget.tsx');
+        });
+
+        it('should report all components for a single orphaned targetId', () => {
+            const registry = {
+                'missing.target': [
+                    {
+                        targetId: 'missing.target',
+                        path: 'extensions/a/comp.tsx',
+                        namespace: 'A',
+                        componentName: 'A_Comp',
+                        order: 0,
+                    },
+                    {
+                        targetId: 'missing.target',
+                        path: 'extensions/b/comp.tsx',
+                        namespace: 'B',
+                        componentName: 'B_Comp',
+                        order: 1,
+                    },
+                ],
+            };
+            const declared = new Set<string>();
+
+            const orphaned = validateTargetRegistry(registry, declared);
+            expect(orphaned).toHaveLength(2);
+        });
+
+        it('should return empty array for empty registry', () => {
+            const orphaned = validateTargetRegistry({}, new Set(['some.target']));
+            expect(orphaned).toHaveLength(0);
+        });
+    });
 });

packages/storefront-next-dev/dist/index.js

@@ -465,3 +465,68 @@ export function buildTargetRegistry(
 
     return { componentRegistry, contextProviders, actionHookRegistry };
 }
+
+const TARGET_ID_PATTERN = /<UITarget[\s][^>]*targetId=["']([^"']+)["']/g;
+const EXCLUDED_DIRS = new Set(['ui-target-dev-mode', 'ui-target-smoke-test']);
+
+/**
+ * Recursively collect all UITarget IDs declared in template source files.
+ * Excludes extension directories so only "real" UITarget placements are counted.
+ */
+export function collectUITargetIds(sourceDir: string): Set<string> {
+    const result = new Set<string>();
+
+    function walk(dir: string) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === 'extensions' || EXCLUDED_DIRS.has(entry.name)) continue;
+                walk(fullPath);
+            } else if (
+                entry.isFile() &&
+                /\.(tsx?|jsx?)$/.test(entry.name) &&
+                !/\.test\.(tsx?|jsx?)$/.test(entry.name)
+            ) {
+                const content = fs.readFileSync(fullPath, 'utf-8');
+                TARGET_ID_PATTERN.lastIndex = 0;
+                let match;
+                while ((match = TARGET_ID_PATTERN.exec(content)) !== null) {
+                    result.add(match[1]);
+                }
+            }
+        }
+    }
+
+    walk(sourceDir);
+    return result;
+}
+
+export interface OrphanedTarget {
+    targetId: string;
+    extension: string;
+    componentPath: string;
+}
+
+/**
+ * Validate that all targetIds in the component registry correspond to
+ * UITarget declarations in the template source. Returns orphaned entries.
+ */
+export function validateTargetRegistry(
+    componentRegistry: TargetComponentRegistry,
+    declaredTargetIds: Set<string>
+): OrphanedTarget[] {
+    const orphaned: OrphanedTarget[] = [];
+    for (const targetId in componentRegistry) {
+        if (!declaredTargetIds.has(targetId)) {
+            for (const entry of componentRegistry[targetId]) {
+                orphaned.push({
+                    targetId,
+                    extension: entry.namespace,
+                    componentPath: entry.path,
+                });
+            }
+        }
+    }
+    return orphaned;
+}

packages/storefront-next-dev/dist/index.js.map

@@ -31,10 +31,14 @@ const viteConfig = {
 vi.mock('../extensibility/target-utils', () => ({
     buildTargetRegistry: vi.fn(),
     transformTargets: vi.fn(),
+    collectUITargetIds: vi.fn(),
+    validateTargetRegistry: vi.fn(),
 }));
 
 import {
     buildTargetRegistry,
+    collectUITargetIds,
+    validateTargetRegistry,
     type TargetComponentRegistry,
     type TargetContextProviderConfig,
     transformTargets,
@@ -75,6 +79,8 @@ describe('transformTargetPlaceholderPlugin', () => {
             actionHookRegistry: {},
         }));
         transformTargetsMock = vi.mocked(transformTargets);
+        vi.mocked(collectUITargetIds).mockReturnValue(new Set(['test.target']));
+        vi.mocked(validateTargetRegistry).mockReturnValue([]);
         vi.spyOn(process, 'cwd').mockReturnValue('/project');
 
         vitePlugin = transformTargetPlaceholderPlugin();
@@ -166,4 +172,32 @@ describe('transformTargetPlaceholderPlugin', () => {
         );
         errorSpy.mockRestore();
     });
+
+    it('should throw when extensions target non-existent UITarget IDs', () => {
+        vi.mocked(validateTargetRegistry).mockReturnValue([
+            {
+                targetId: 'sfcc.nonexistent.target',
+                extension: 'MyExt',
+                componentPath: 'extensions/my-ext/comp.tsx',
+            },
+        ]);
+
+        expect(() => vitePlugin.buildStart()).toThrow(
+            /1 extension component\(s\) target UITarget IDs that do not exist/
+        );
+        expect(() => vitePlugin.buildStart()).toThrow(/sfcc\.nonexistent\.target/);
+    });
+
+    it('should not throw when all extension targets are valid', () => {
+        vi.mocked(validateTargetRegistry).mockReturnValue([]);
+
+        expect(() => vitePlugin.buildStart()).not.toThrow();
+    });
+
+    it('should call collectUITargetIds with sourceDir and validateTargetRegistry with registry', () => {
+        vitePlugin.buildStart();
+
+        expect(collectUITargetIds).toHaveBeenCalledWith('src');
+        expect(validateTargetRegistry).toHaveBeenCalledWith(mockComponentRegistry, new Set(['test.target']));
+    });
 });