@sfdc-webapps/cli 1.0.2

package/test/unit/validation.spec.ts

@@ -0,0 +1,311 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  validateAndResolveFeaturePath,
+  validateAndResolveAppPath,
+  getWebApplicationPath,
+  ValidationError,
+  validateAppOrFeatureName
+} from '../../src/utils/validation.js';
+import { mkdirSync, writeFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('validation', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `validation-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (tempDir) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('getWebApplicationPath', () => {
+    it('should construct web application path correctly', () => {
+      const basePath = '/path/to/my-app';
+      const result = getWebApplicationPath(basePath);
+
+      expect(result).toBe('/path/to/my-app/digitalExperiences/webApplications/my-app');
+    });
+
+    it('should handle paths with trailing slash', () => {
+      const basePath = '/path/to/my-app/';
+      const result = getWebApplicationPath(basePath);
+
+      expect(result).toContain('digitalExperiences/webApplications');
+    });
+  });
+
+  describe('validateAndResolveFeaturePath', () => {
+    it('should validate and resolve an absolute feature path', () => {
+      // Create valid feature directory with feature.ts
+      const featurePath = join(tempDir, 'valid-feature');
+      mkdirSync(featurePath, { recursive: true });
+      writeFileSync(join(featurePath, 'feature.ts'), 'export default {};');
+
+      const result = validateAndResolveFeaturePath(featurePath);
+
+      expect(result).toBe(featurePath);
+    });
+
+    it('should throw ValidationError if feature path does not exist', () => {
+      const nonExistentPath = join(tempDir, 'non-existent-feature');
+
+      expect(() => validateAndResolveFeaturePath(nonExistentPath)).toThrow(ValidationError);
+      expect(() => validateAndResolveFeaturePath(nonExistentPath)).toThrow(
+        /Feature path.*does not exist/
+      );
+    });
+
+    it('should throw ValidationError if feature path is not a directory', () => {
+      // Create a file instead of directory
+      const filePath = join(tempDir, 'feature-file');
+      writeFileSync(filePath, 'not a directory');
+
+      expect(() => validateAndResolveFeaturePath(filePath)).toThrow(ValidationError);
+      expect(() => validateAndResolveFeaturePath(filePath)).toThrow(
+        /is not a directory/
+      );
+    });
+
+    it('should throw ValidationError if feature.ts is missing', () => {
+      // Create directory without feature.ts
+      const featurePath = join(tempDir, 'feature-no-feature');
+      mkdirSync(featurePath, { recursive: true });
+
+      expect(() => validateAndResolveFeaturePath(featurePath)).toThrow(ValidationError);
+      expect(() => validateAndResolveFeaturePath(featurePath)).toThrow(
+        /does not contain a feature.ts file/
+      );
+    });
+
+    it('should return absolute path for valid feature', () => {
+      const featurePath = join(tempDir, 'abs-path-feature');
+      mkdirSync(featurePath, { recursive: true });
+      writeFileSync(join(featurePath, 'feature.ts'), 'export default {};');
+
+      const result = validateAndResolveFeaturePath(featurePath);
+
+      expect(result).toBe(featurePath);
+      expect(result.startsWith('/')).toBe(true);
+    });
+  });
+
+  describe('validateAndResolveAppPath', () => {
+    it('should validate and resolve a valid app path', () => {
+      // Create valid app structure
+      const appPath = join(tempDir, 'valid-app');
+      const webAppPath = join(appPath, 'digitalExperiences/webApplications/valid-app');
+      mkdirSync(webAppPath, { recursive: true });
+      writeFileSync(join(webAppPath, 'package.json'), '{}');
+
+      const result = validateAndResolveAppPath(appPath);
+
+      expect(result).toBe(appPath);
+    });
+
+    it('should throw ValidationError if app path does not exist', () => {
+      const nonExistentPath = join(tempDir, 'non-existent-app');
+
+      expect(() => validateAndResolveAppPath(nonExistentPath)).toThrow(ValidationError);
+      expect(() => validateAndResolveAppPath(nonExistentPath)).toThrow(
+        /App path.*does not exist/
+      );
+    });
+
+    it('should throw ValidationError if app path is not a directory', () => {
+      // Create a file instead of directory
+      const filePath = join(tempDir, 'app-file');
+      writeFileSync(filePath, 'not a directory');
+
+      expect(() => validateAndResolveAppPath(filePath)).toThrow(ValidationError);
+      expect(() => validateAndResolveAppPath(filePath)).toThrow(
+        /is not a directory/
+      );
+    });
+
+    it('should throw ValidationError if web application directory is missing', () => {
+      // Create app directory but without web application structure
+      const appPath = join(tempDir, 'app-no-webdir');
+      mkdirSync(appPath, { recursive: true });
+
+      expect(() => validateAndResolveAppPath(appPath)).toThrow(ValidationError);
+      expect(() => validateAndResolveAppPath(appPath)).toThrow(
+        /Web application directory does not exist/
+      );
+      expect(() => validateAndResolveAppPath(appPath)).toThrow(
+        /digitalExperiences\/webApplications/
+      );
+    });
+
+    it('should throw ValidationError if web application path is a file not directory', () => {
+      // Create app structure with web application as file
+      const appPath = join(tempDir, 'app-webfile');
+      const webAppBasePath = join(appPath, 'digitalExperiences/webApplications');
+      mkdirSync(webAppBasePath, { recursive: true });
+
+      // Create a file instead of the expected directory
+      const webAppPath = join(webAppBasePath, 'app-webfile');
+      writeFileSync(webAppPath, 'not a directory');
+
+      expect(() => validateAndResolveAppPath(appPath)).toThrow(ValidationError);
+      expect(() => validateAndResolveAppPath(appPath)).toThrow(
+        /is not a directory/
+      );
+    });
+
+    it('should throw ValidationError if package.json is missing', () => {
+      // Create web application directory without package.json
+      const appPath = join(tempDir, 'app-no-package');
+      const webAppPath = join(appPath, 'digitalExperiences/webApplications/app-no-package');
+      mkdirSync(webAppPath, { recursive: true });
+
+      expect(() => validateAndResolveAppPath(appPath)).toThrow(ValidationError);
+      expect(() => validateAndResolveAppPath(appPath)).toThrow(
+        /does not contain a package.json file/
+      );
+    });
+
+    it('should accept absolute paths', () => {
+      const appPath = join(tempDir, 'abs-app');
+      const webAppPath = join(appPath, 'digitalExperiences/webApplications/abs-app');
+      mkdirSync(webAppPath, { recursive: true });
+      writeFileSync(join(webAppPath, 'package.json'), '{}');
+
+      const result = validateAndResolveAppPath(appPath);
+
+      expect(result).toBe(appPath);
+      expect(result.startsWith('/')).toBe(true);
+    });
+
+    it('should validate complete app structure', () => {
+      // Create complete valid structure
+      const appPath = join(tempDir, 'complete-app');
+      const webAppPath = join(appPath, 'digitalExperiences/webApplications/complete-app');
+      mkdirSync(webAppPath, { recursive: true });
+      writeFileSync(join(webAppPath, 'package.json'), JSON.stringify({
+        name: 'complete-app',
+        version: '1.0.0'
+      }));
+
+      // Should not throw
+      const result = validateAndResolveAppPath(appPath);
+
+      expect(result).toBe(appPath);
+    });
+  });
+
+  describe('ValidationError', () => {
+    it('should be throwable with custom message', () => {
+      const error = new ValidationError('Custom validation error');
+
+      expect(error.message).toBe('Custom validation error');
+      expect(error.name).toBe('ValidationError');
+      expect(error).toBeInstanceOf(Error);
+    });
+
+    it('should be catchable as ValidationError', () => {
+      try {
+        throw new ValidationError('Test error');
+      } catch (err) {
+        expect(err).toBeInstanceOf(ValidationError);
+        expect((err as ValidationError).name).toBe('ValidationError');
+      }
+    });
+  });
+
+  describe('validateAppFeatureName', () => {
+    it('should accept valid kebab-case names', () => {
+      expect(() => validateAppOrFeatureName('nav-menu')).not.toThrow();
+      expect(() => validateAppOrFeatureName('user-auth')).not.toThrow();
+      expect(() => validateAppOrFeatureName('dashboard-v2')).not.toThrow();
+      expect(() => validateAppOrFeatureName('simple')).not.toThrow();
+      expect(() => validateAppOrFeatureName('abc-123-def')).not.toThrow();
+      expect(() => validateAppOrFeatureName('a')).not.toThrow();
+    });
+
+    it('should accept names with numbers', () => {
+      expect(() => validateAppOrFeatureName('feature123')).not.toThrow();
+      expect(() => validateAppOrFeatureName('123feature')).not.toThrow();
+      expect(() => validateAppOrFeatureName('v2-dashboard')).not.toThrow();
+    });
+
+    it('should reject empty names', () => {
+      expect(() => validateAppOrFeatureName('')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('')).toThrow(/cannot be empty/);
+      expect(() => validateAppOrFeatureName('   ')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('   ')).toThrow(/cannot be empty/);
+    });
+
+    it('should reject names with uppercase letters', () => {
+      expect(() => validateAppOrFeatureName('Nav-Menu')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('Nav-Menu')).toThrow(/invalid.*kebab-case/);
+      expect(() => validateAppOrFeatureName('navMenu')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('NAV-MENU')).toThrow(ValidationError);
+    });
+
+    it('should reject names with underscores', () => {
+      expect(() => validateAppOrFeatureName('nav_menu')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('nav_menu')).toThrow(/invalid.*kebab-case/);
+      expect(() => validateAppOrFeatureName('user_auth_v2')).toThrow(ValidationError);
+    });
+
+    it('should reject names starting with hyphen', () => {
+      expect(() => validateAppOrFeatureName('-nav')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('-nav')).toThrow(/invalid.*kebab-case/);
+      expect(() => validateAppOrFeatureName('-nav-menu')).toThrow(ValidationError);
+    });
+
+    it('should reject names ending with hyphen', () => {
+      expect(() => validateAppOrFeatureName('nav-')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('nav-')).toThrow(/invalid.*kebab-case/);
+      expect(() => validateAppOrFeatureName('nav-menu-')).toThrow(ValidationError);
+    });
+
+    it('should reject names with consecutive hyphens', () => {
+      expect(() => validateAppOrFeatureName('nav--menu')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('nav--menu')).toThrow(/invalid.*kebab-case/);
+      expect(() => validateAppOrFeatureName('a--b--c')).toThrow(ValidationError);
+    });
+
+    it('should reject reserved names', () => {
+      expect(() => validateAppOrFeatureName('app')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('app')).toThrow(/reserved/);
+      expect(() => validateAppOrFeatureName('feature')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('feature')).toThrow(/reserved/);
+    });
+
+    it('should reject names that are too long', () => {
+      const longName = 'a'.repeat(51);
+      expect(() => validateAppOrFeatureName(longName)).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName(longName)).toThrow(/too long.*50 characters/);
+    });
+
+    it('should accept names with exactly 50 characters', () => {
+      const maxLengthName = 'a'.repeat(50);
+      expect(() => validateAppOrFeatureName(maxLengthName)).not.toThrow();
+    });
+
+    it('should reject names with special characters', () => {
+      expect(() => validateAppOrFeatureName('nav@menu')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('nav.menu')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('nav menu')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('nav/menu')).toThrow(ValidationError);
+      expect(() => validateAppOrFeatureName('nav\\menu')).toThrow(ValidationError);
+    });
+
+    it('should provide helpful error messages with examples', () => {
+      try {
+        validateAppOrFeatureName('Invalid_Name');
+      } catch (err) {
+        expect(err).toBeInstanceOf(ValidationError);
+        expect((err as Error).message).toContain('Examples:');
+        expect((err as Error).message).toContain('nav-menu');
+      }
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022"],
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.spec.ts", "**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from 'vitest/config';
+import { resolve } from 'path';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['test/**/*.spec.ts'],
+    exclude: ['**/node_modules/**', '**/dist/**', '**/gold/**'],
+    setupFiles: ['./test/setup.ts'],
+    testTimeout: 30000, // E2E tests may take longer
+  },
+  resolve: {
+    alias: {
+      '@': resolve(__dirname, './src'),
+    },
+  },
+});