@sfdc-webapps/cli 1.0.2

package/test/unit/patch-loader.spec.ts

@@ -0,0 +1,238 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { loadFeature, FeatureLoadError } from '../../src/core/patch-loader.js';
+import { mkdirSync, writeFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('patch-loader', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `patch-loader-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (tempDir) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  /**
+   * Helper to create a feature with feature.ts
+   */
+  function createFeatureWithFeature(name: string, patchesContent: string): string {
+    const featurePath = join(tempDir, name);
+    mkdirSync(featurePath, { recursive: true });
+    writeFileSync(join(featurePath, 'feature.ts'), patchesContent);
+    return featurePath;
+  }
+
+  describe('loadFeature', () => {
+    it('should load feature with default values', async () => {
+      const featurePath = createFeatureWithFeature('feature-defaults', `
+const feature = {};
+export default feature;
+`);
+
+      const result = await loadFeature(featurePath);
+
+      expect(result.features).toHaveLength(1);
+      expect(result.templateDir).toBe('template');
+      expect(result.dependencies).toEqual([]);
+      expect(result.webAppName).toBe('feature-defaults');
+      expect(result.routeFilePath).toBe('digitalExperiences/webApplications/feature-defaults/src/routes.tsx');
+    });
+
+    it('should load feature with custom templateDir', async () => {
+      const featurePath = createFeatureWithFeature('feature-custom-dir', `
+const feature = {
+  templateDir: 'custom-templates'
+};
+export default feature;
+`);
+
+      const result = await loadFeature(featurePath);
+
+      expect(result.templateDir).toBe('custom-templates');
+    });
+
+    it('should load feature with dependencies', async () => {
+      const featurePath = createFeatureWithFeature('feature-with-deps', `
+const feature = {
+  dependencies: ['../feature-a', '../feature-b']
+};
+export default feature;
+`);
+
+      const result = await loadFeature(featurePath);
+
+      expect(result.dependencies).toEqual(['../feature-a', '../feature-b']);
+    });
+
+    it('should load feature with custom webAppName', async () => {
+      const featurePath = createFeatureWithFeature('feature-custom-name', `
+const feature = {
+  webAppName: 'my-custom-app'
+};
+export default feature;
+`);
+
+      const result = await loadFeature(featurePath);
+
+      expect(result.webAppName).toBe('my-custom-app');
+    });
+
+    it('should load feature array', async () => {
+      const featurePath = createFeatureWithFeature('feature-array', `
+const feature1 = { templateDir: 'src1' };
+const feature2 = { templateDir: 'src2' };
+export default [feature1, feature2];
+`);
+
+      const result = await loadFeature(featurePath);
+
+      expect(result.features).toHaveLength(2);
+      // templateDir should be from the last feature
+      expect(result.templateDir).toBe('src2');
+    });
+
+    it('should throw FeatureLoadError if feature.ts is missing', async () => {
+      const featurePath = join(tempDir, 'no-feature');
+      mkdirSync(featurePath, { recursive: true });
+
+      await expect(loadFeature(featurePath)).rejects.toThrow(FeatureLoadError);
+      await expect(loadFeature(featurePath)).rejects.toThrow(/No feature.ts found/);
+    });
+
+    it('should throw FeatureLoadError if feature.ts has no default export', async () => {
+      const featurePath = createFeatureWithFeature('no-default-export', `
+export const notDefault = {};
+`);
+
+      await expect(loadFeature(featurePath)).rejects.toThrow(FeatureLoadError);
+      await expect(loadFeature(featurePath)).rejects.toThrow(/must have a default export/);
+    });
+
+    it('should throw FeatureLoadError if default export is not an object or array', async () => {
+      const featurePath = createFeatureWithFeature('invalid-export-string', `
+export default "not an object";
+`);
+
+      await expect(loadFeature(featurePath)).rejects.toThrow(FeatureLoadError);
+      await expect(loadFeature(featurePath)).rejects.toThrow(/must be a Feature object or Feature/);
+    });
+
+    it('should throw FeatureLoadError if default export is null', async () => {
+      const featurePath = createFeatureWithFeature('invalid-export-null', `
+export default null;
+`);
+
+      await expect(loadFeature(featurePath)).rejects.toThrow(FeatureLoadError);
+      await expect(loadFeature(featurePath)).rejects.toThrow(/must have a default export/);
+    });
+
+    it('should throw FeatureLoadError if default export is a number', async () => {
+      const featurePath = createFeatureWithFeature('invalid-export-number', `
+export default 123;
+`);
+
+      await expect(loadFeature(featurePath)).rejects.toThrow(FeatureLoadError);
+      await expect(loadFeature(featurePath)).rejects.toThrow(/must be a Feature object or Feature/);
+    });
+
+    it('should throw error if feature.ts file has syntax error', async () => {
+      const featurePath = createFeatureWithFeature('syntax-error', `
+this is invalid javascript syntax {{{}
+`);
+
+      await expect(loadFeature(featurePath)).rejects.toThrow(FeatureLoadError);
+      await expect(loadFeature(featurePath)).rejects.toThrow(/Failed to load feature/);
+    });
+
+    it('should merge dependencies from multiple features', async () => {
+      const featurePath = createFeatureWithFeature('multi-deps', `
+const feature1 = { dependencies: ['../dep-a', '../dep-b'] };
+const feature2 = { dependencies: ['../dep-b', '../dep-c'] };
+export default [feature1, feature2];
+`);
+
+      const result = await loadFeature(featurePath);
+
+      // Should deduplicate dep-b
+      expect(result.dependencies).toContain('../dep-a');
+      expect(result.dependencies).toContain('../dep-b');
+      expect(result.dependencies).toContain('../dep-c');
+      expect(result.dependencies).toHaveLength(3);
+    });
+
+    it('should derive webAppName from directory basename', async () => {
+      const featurePath = createFeatureWithFeature('my-awesome-feature', `
+const feature = {};
+export default feature;
+`);
+
+      const result = await loadFeature(featurePath);
+
+      expect(result.webAppName).toBe('my-awesome-feature');
+    });
+
+    it('should construct routeFilePath with default values', async () => {
+      const featurePath = createFeatureWithFeature('route-defaults', `
+const feature = {};
+export default feature;
+`);
+
+      const result = await loadFeature(featurePath);
+
+      expect(result.routeFilePath).toBe(
+        'digitalExperiences/webApplications/route-defaults/src/routes.tsx'
+      );
+    });
+
+    it('should use custom routeFilePath if provided', async () => {
+      const featurePath = createFeatureWithFeature('custom-routes', `
+const feature = {
+  routeFilePath: 'custom/path/to/routes.tsx'
+};
+export default feature;
+`);
+
+      const result = await loadFeature(featurePath);
+
+      expect(result.routeFilePath).toBe('custom/path/to/routes.tsx');
+    });
+
+    it('should override defaults with later feature values in array', async () => {
+      const featurePath = createFeatureWithFeature('override-test', `
+const feature1 = { templateDir: 'first' };
+const feature2 = { templateDir: 'second' };
+export default [feature1, feature2];
+`);
+
+      const result = await loadFeature(featurePath);
+
+      // Last feature wins
+      expect(result.templateDir).toBe('second');
+    });
+  });
+
+  describe('FeatureLoadError', () => {
+    it('should be throwable with custom message', () => {
+      const error = new FeatureLoadError('Custom load error');
+
+      expect(error.message).toBe('Custom load error');
+      expect(error.name).toBe('FeatureLoadError');
+      expect(error).toBeInstanceOf(Error);
+    });
+
+    it('should be catchable as FeatureLoadError', () => {
+      try {
+        throw new FeatureLoadError('Test error');
+      } catch (err) {
+        expect(err).toBeInstanceOf(FeatureLoadError);
+        expect((err as FeatureLoadError).name).toBe('FeatureLoadError');
+      }
+    });
+  });
+});

package/test/unit/path-mappings.spec.ts

@@ -0,0 +1,241 @@
+import { describe, it, expect } from 'vitest';
+import {
+  getDefaultPathMappings,
+  arePathMappingsEnabled,
+  getEffectivePathMappings,
+  applyPathMappings
+} from '../../src/utils/path-mappings.js';
+
+describe('path-mappings', () => {
+  describe('getDefaultPathMappings', () => {
+    it('should create default mapping with feature name', () => {
+      const mappings = getDefaultPathMappings('feature-navigation');
+      expect(mappings).toEqual([
+        {
+          from: 'webApp',
+          to: 'digitalExperiences/webApplications/feature-navigation'
+        }
+      ]);
+    });
+
+    it('should handle different feature names', () => {
+      const mappings = getDefaultPathMappings('feature-vibe-coding-starter');
+      expect(mappings).toEqual([
+        {
+          from: 'webApp',
+          to: 'digitalExperiences/webApplications/feature-vibe-coding-starter'
+        }
+      ]);
+    });
+  });
+
+  describe('arePathMappingsEnabled', () => {
+    it('should return true when pathMappings is undefined (default)', () => {
+      expect(arePathMappingsEnabled(undefined)).toBe(true);
+    });
+
+    it('should return true when enabled is explicitly true', () => {
+      expect(arePathMappingsEnabled({ enabled: true })).toBe(true);
+    });
+
+    it('should return false when enabled is explicitly false', () => {
+      expect(arePathMappingsEnabled({ enabled: false })).toBe(false);
+    });
+
+    it('should return true when enabled is not specified but mappings provided', () => {
+      expect(arePathMappingsEnabled({ mappings: [] })).toBe(true);
+    });
+
+    it('should return true for empty config object', () => {
+      expect(arePathMappingsEnabled({})).toBe(true);
+    });
+  });
+
+  describe('getEffectivePathMappings', () => {
+    it('should return default mappings when pathMappings is undefined', () => {
+      const mappings = getEffectivePathMappings('feature-test', undefined);
+      expect(mappings).toEqual([
+        {
+          from: 'webApp',
+          to: 'digitalExperiences/webApplications/feature-test'
+        }
+      ]);
+    });
+
+    it('should return empty array when disabled', () => {
+      const mappings = getEffectivePathMappings('feature-test', { enabled: false });
+      expect(mappings).toEqual([]);
+    });
+
+    it('should return custom mappings when provided', () => {
+      const custom = [{ from: 'web', to: 'custom/path' }];
+      const mappings = getEffectivePathMappings('feature-test', { mappings: custom });
+      expect(mappings).toEqual(custom);
+    });
+
+    it('should return default when mappings array is empty', () => {
+      const mappings = getEffectivePathMappings('feature-test', { mappings: [] });
+      expect(mappings).toEqual([
+        {
+          from: 'webApp',
+          to: 'digitalExperiences/webApplications/feature-test'
+        }
+      ]);
+    });
+
+    it('should return default when pathMappings is empty object', () => {
+      const mappings = getEffectivePathMappings('feature-test', {});
+      expect(mappings).toEqual([
+        {
+          from: 'webApp',
+          to: 'digitalExperiences/webApplications/feature-test'
+        }
+      ]);
+    });
+
+    it('should respect enabled: false even with custom mappings', () => {
+      const custom = [{ from: 'web', to: 'custom/path' }];
+      const mappings = getEffectivePathMappings('feature-test', {
+        enabled: false,
+        mappings: custom
+      });
+      expect(mappings).toEqual([]);
+    });
+  });
+
+  describe('applyPathMappings', () => {
+    const defaultMappings = [
+      { from: 'webApp', to: 'digitalExperiences/webApplications/feature-nav' }
+    ];
+
+    describe('basic mapping', () => {
+      it('should apply mapping to webApp path', () => {
+        const result = applyPathMappings('webApp/src/app.tsx', defaultMappings);
+        expect(result).toBe('digitalExperiences/webApplications/feature-nav/src/app.tsx');
+      });
+
+      it('should apply mapping to nested webApp path', () => {
+        const result = applyPathMappings('webApp/src/components/Header.tsx', defaultMappings);
+        expect(result).toBe('digitalExperiences/webApplications/feature-nav/src/components/Header.tsx');
+      });
+
+      it('should apply mapping to deeply nested paths', () => {
+        const result = applyPathMappings('webApp/src/a/b/c/d/file.tsx', defaultMappings);
+        expect(result).toBe('digitalExperiences/webApplications/feature-nav/src/a/b/c/d/file.tsx');
+      });
+    });
+
+    describe('no match scenarios', () => {
+      it('should not modify path that does not match mapping prefix', () => {
+        const result = applyPathMappings('src/app.tsx', defaultMappings);
+        expect(result).toBe('src/app.tsx');
+      });
+
+      it('should not modify full path format (backwards compat)', () => {
+        const oldPath = 'digitalExperiences/webApplications/feature-nav/src/app.tsx';
+        const result = applyPathMappings(oldPath, defaultMappings);
+        expect(result).toBe(oldPath);
+      });
+
+      it('should not modify paths that partially match', () => {
+        const result = applyPathMappings('webApplication/src/app.tsx', defaultMappings);
+        expect(result).toBe('webApplication/src/app.tsx');
+      });
+
+      it('should not modify paths with mapping prefix in middle', () => {
+        const result = applyPathMappings('src/webApp/app.tsx', defaultMappings);
+        expect(result).toBe('src/webApp/app.tsx');
+      });
+    });
+
+    describe('empty or no mappings', () => {
+      it('should return path unchanged when no mappings provided', () => {
+        const result = applyPathMappings('webApp/src/app.tsx', []);
+        expect(result).toBe('webApp/src/app.tsx');
+      });
+    });
+
+    describe('exact match', () => {
+      it('should handle exact match of mapping prefix', () => {
+        const result = applyPathMappings('webApp', defaultMappings);
+        expect(result).toBe('digitalExperiences/webApplications/feature-nav');
+      });
+
+      it('should handle exact match with file extension', () => {
+        const result = applyPathMappings('webApp.tsx', defaultMappings);
+        expect(result).toBe('webApp.tsx'); // No match, doesn't start with 'webApp/'
+      });
+    });
+
+    describe('multiple mappings', () => {
+      it('should apply first matching mapping when multiple provided', () => {
+        const mappings = [
+          { from: 'webApp', to: 'path1' },
+          { from: 'webApp', to: 'path2' } // This should not be used
+        ];
+        const result = applyPathMappings('webApp/file.txt', mappings);
+        expect(result).toBe('path1/file.txt');
+      });
+
+      it('should try mappings in order', () => {
+        const mappings = [
+          { from: 'foo', to: 'path-foo' },
+          { from: 'webApp', to: 'path-webapp' },
+          { from: 'bar', to: 'path-bar' }
+        ];
+        const result = applyPathMappings('webApp/file.txt', mappings);
+        expect(result).toBe('path-webapp/file.txt');
+      });
+
+      it('should apply different mappings for different prefixes', () => {
+        const mappings = [
+          { from: 'web', to: 'custom/web' },
+          { from: 'shared', to: 'common/shared' }
+        ];
+        expect(applyPathMappings('web/src/app.tsx', mappings)).toBe('custom/web/src/app.tsx');
+        expect(applyPathMappings('shared/utils.ts', mappings)).toBe('common/shared/utils.ts');
+      });
+    });
+
+    describe('custom mapping prefixes', () => {
+      it('should handle custom mapping prefixes', () => {
+        const mappings = [{ from: 'web', to: 'custom/web/path' }];
+        const result = applyPathMappings('web/src/app.tsx', mappings);
+        expect(result).toBe('custom/web/path/src/app.tsx');
+      });
+
+      it('should handle short custom prefix', () => {
+        const mappings = [{ from: 'w', to: 'digitalExperiences/webApplications/app' }];
+        const result = applyPathMappings('w/src/app.tsx', mappings);
+        expect(result).toBe('digitalExperiences/webApplications/app/src/app.tsx');
+      });
+    });
+
+    describe('edge cases', () => {
+      it('should handle paths with special characters', () => {
+        const result = applyPathMappings('webApp/src/app-config.tsx', defaultMappings);
+        expect(result).toBe('digitalExperiences/webApplications/feature-nav/src/app-config.tsx');
+      });
+
+      it('should handle paths with dots', () => {
+        const result = applyPathMappings('webApp/src/app.config.tsx', defaultMappings);
+        expect(result).toBe('digitalExperiences/webApplications/feature-nav/src/app.config.tsx');
+      });
+
+      it('should handle paths with underscores', () => {
+        const result = applyPathMappings('webApp/src/__inherit__app.tsx', defaultMappings);
+        expect(result).toBe('digitalExperiences/webApplications/feature-nav/src/__inherit__app.tsx');
+      });
+
+      it('should handle empty path', () => {
+        const result = applyPathMappings('', defaultMappings);
+        expect(result).toBe('');
+      });
+
+      it('should handle root level file with no slash', () => {
+        const result = applyPathMappings('README.md', defaultMappings);
+        expect(result).toBe('README.md');
+      });
+    });
+  });
+});