fix(releaseconfig): do not use git ref to get release config package…

…s in validate



validate shouldn't require the use of release defn generated from git, as validate could introduce
new packages which are not committed to the current release when done locally or the tag for it is
yet to exit, so it should do a simple filter based on the predicates provided.This will fix the
issue as mentioned in 1259

fixes #1259

packages/sfpowerscripts-cli/src/impl/release/ReleaseConfig.ts

@@ -0,0 +1,96 @@
+import * as fs from 'fs-extra';
+import ProjectConfig from '@dxatscale/sfpowerscripts.core/lib/project/ProjectConfig';
+import Ajv, { _ } from 'ajv';
+import ReleaseDefinitionGeneratorConfigSchema from './ReleaseDefinitionGeneratorConfigSchema';
+import lodash = require('lodash');
+import yaml from 'js-yaml';
+import { Logger } from '@dxatscale/sfp-logger';
+const path = require('path');
+
+export default class ReleaseConfig {
+    private _releaseDefinitionGeneratorSchema: ReleaseDefinitionGeneratorConfigSchema;
+
+    get releaseDefinitionGeneratorConfigSchema() {
+        // Return clone of releaseDefinition for immutability
+        return lodash.cloneDeep(this._releaseDefinitionGeneratorSchema);
+    }
+
+    public constructor(private logger: Logger, pathToReleaseDefinition: string) {
+        this._releaseDefinitionGeneratorSchema = yaml.load(fs.readFileSync(pathToReleaseDefinition, 'utf8'));
+        this.validateReleaseDefinitionGeneratorConfig(this._releaseDefinitionGeneratorSchema);
+
+        // Easy to handle here than with schema
+        if (
+            this._releaseDefinitionGeneratorSchema.includeOnlyArtifacts &&
+            this.releaseDefinitionGeneratorConfigSchema.excludeArtifacts
+        ) {
+            throw new Error('Error: Invalid schema: either use includeArtifacts or excludeArtifacts');
+        }
+        // Easy to handle here than with schema
+        if (
+            this._releaseDefinitionGeneratorSchema.includeOnlyPackageDependencies &&
+            this.releaseDefinitionGeneratorConfigSchema.excludePackageDependencies
+        ) {
+            throw new Error(
+                'Error: Invalid schema: either use includePackageDependencies or excludePackageDependencies'
+            );
+        }
+
+        // Workaround for jsonschema not supporting validation based on dependency value
+        if (
+            this._releaseDefinitionGeneratorSchema.releasedefinitionProperties?.baselineOrg &&
+            !this._releaseDefinitionGeneratorSchema.releasedefinitionProperties?.skipIfAlreadyInstalled
+        )
+            throw new Error("Release option 'skipIfAlreadyInstalled' must be true for 'baselineOrg'");
+    }
+
+    public getPackagesAsPerReleaseConfig(directory?: string): string[] {
+        let packages: string[] = [];
+        let projectConfig = ProjectConfig.getSFDXProjectConfig(directory);
+        //Read sfdx project json
+        let sfdxPackages = ProjectConfig.getAllPackagesFromProjectConfig(projectConfig);
+        for (const sfdxPackage of sfdxPackages) {
+            if (this.getArtifactPredicate(sfdxPackage)) {
+                packages.push(sfdxPackage);
+            }
+        }
+
+        return packages;
+    }
+
+    private validateReleaseDefinitionGeneratorConfig(
+        releaseDefinitionGeneratorSchema: ReleaseDefinitionGeneratorConfigSchema
+    ): void {
+        let schema = fs.readJSONSync(
+            path.join(__dirname, '..', '..', '..', 'resources', 'schemas', 'releasedefinitiongenerator.schema.json'),
+            { encoding: 'UTF-8' }
+        );
+
+        let validator = new Ajv({ allErrors: true }).compile(schema);
+        let validationResult = validator(releaseDefinitionGeneratorSchema);
+
+        if (!validationResult) {
+            let errorMsg: string =
+                `Release definition generation config does not meet schema requirements, ` +
+                `found ${validator.errors.length} validation errors:\n`;
+
+            validator.errors.forEach((error, errorNum) => {
+                errorMsg += `\n${errorNum + 1}: ${error.instancePath}: ${error.message} ${JSON.stringify(
+                    error.params,
+                    null,
+                    4
+                )}`;
+            });
+
+            throw new Error(errorMsg);
+        }
+    }
+
+    private getArtifactPredicate(artifact: string): boolean {
+        if (this.releaseDefinitionGeneratorConfigSchema.includeOnlyArtifacts) {
+            return this.releaseDefinitionGeneratorConfigSchema.includeOnlyArtifacts?.includes(artifact);
+        } else if (this.releaseDefinitionGeneratorConfigSchema.excludeArtifacts) {
+            return !this.releaseDefinitionGeneratorConfigSchema.excludeArtifacts?.includes(artifact);
+        } else return true;
+    }
+}

packages/sfpowerscripts-cli/src/impl/release/ReleaseDefinitionGenerator.ts

@@ -143,7 +143,6 @@ export default class ReleaseDefinitionGenerator {
                     LoggerLevel.WARN,
                     this.logger
                 );
-                continue;
             }
         }
 

packages/sfpowerscripts-cli/src/impl/validate/ValidateImpl.ts

@@ -47,9 +47,8 @@ import ExternalPackage2DependencyResolver from '@dxatscale/sfpowerscripts.core/l
 import ExternalDependencyDisplayer from '@dxatscale/sfpowerscripts.core/lib/display/ExternalDependencyDisplayer';
 import { PreDeployHook } from '../deploy/PreDeployHook';
 import GroupConsoleLogs from '../../ui/GroupConsoleLogs';
-import ReleaseDefinitionGenerator from '../release/ReleaseDefinitionGenerator';
-import ReleaseDefinitionSchema from '../release/ReleaseDefinitionSchema';
 import { COLON_MIDDLE_BORDER_TABLE } from '../../ui/TableConstants';
+import ReleaseConfig from '../release/ReleaseConfig';
 const Table = require('cli-table');
 
 export enum ValidateAgainst {
@@ -423,7 +422,7 @@ export default class ValidateImpl implements PostDeployHook, PreDeployHook {
         buildProps.diffOptions = diffOptions;
 
         //Compute packages to be included
-        buildProps.includeOnlyPackages = await computePackagesIfReleaseDefnIsProvided(this.props);
+        buildProps.includeOnlyPackages =  fetchPackagesAsPerReleaseConfig(this.logger,this.props);
         if (buildProps.includeOnlyPackages) {
             printIncludeOnlyPackages(buildProps.includeOnlyPackages);
         }
@@ -455,25 +454,14 @@ export default class ValidateImpl implements PostDeployHook, PreDeployHook {
 
         return generatedPackages;
 
-        async function computePackagesIfReleaseDefnIsProvided(props: ValidateProps) {
+        function fetchPackagesAsPerReleaseConfig(logger:Logger,props: ValidateProps) {
             if (
                 props.validationMode == ValidationMode.FASTFEEDBACK_LIMITED_BY_RELEASE_CONFIG ||
                 props.validationMode == ValidationMode.THOROUGH_LIMITED_BY_RELEASE_CONFIG
             ) {
-                //Generate release definition
-                let releaseDefinitionGenerator: ReleaseDefinitionGenerator = new ReleaseDefinitionGenerator(
-                    new ConsoleLogger(),
-                    'HEAD',
-                    props.releaseConfigPath,
-                    'validate',
-                    'test',
-                    undefined,
-                    true,
-                    false,
-                    true
-                );
-                let releaseDefinition = (await releaseDefinitionGenerator.exec()) as ReleaseDefinitionSchema;
-                return Object.keys(releaseDefinition.artifacts);
+
+                let releaseConfig:ReleaseConfig = new ReleaseConfig(logger, props.releaseConfigPath);
+                return releaseConfig.getPackagesAsPerReleaseConfig();
             }
         }