Merge pull request finos#1394 from rocketstack-matt/validate

Add ability to run validate against an architecture without a pattern…

Author: LeighFinegold

calm/getting-started/README.md

@@ -89,7 +89,7 @@ Verify the installation.
 ```shell
 calm --version
 ```
-This getting started has been verified to work against 0.7.8 of the cli.
+This getting started has been verified to work against 0.7.9 of the cli.
 
 ---
 

cli/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@finos/calm-cli",
-    "version": "0.7.8",
+    "version": "0.7.9",
     "description": "A set of tools for interacting with the Common Architecture Language Model (CALM)",
     "main": "dist/index.js",
     "files": [

cli/src/cli.e2e.spec.ts

@@ -254,7 +254,7 @@ describe('CLI Integration Tests', () => {
 
         // This will enforce that people verify the getting-started guide works prior to any cli change
         const { stdout } = await execPromise(calm('--version'));
-        expect(stdout.trim()).toMatch('0.7.8'); // basic semver check
+        expect(stdout.trim()).toMatch('0.7.9'); // basic semver check
 
         //STEP 1: Generate Architecture From Pattern
         const inputPattern = path.resolve(GETTING_STARTED_DIR, 'conference-signup.pattern.json');

docs/quick-start/index.md

@@ -103,7 +103,7 @@ Verify the installation.
 calm --version
 ```
 
-This getting started has been verified to work against 0.7.8 of the cli.
+This getting started has been verified to work against 0.7.9 of the cli.
 
 ---
 

shared/src/commands/validate/validate.spec.ts

@@ -528,8 +528,45 @@ describe('validate - architecture only', () => {
         expect(response.allValidationOutputs()).not.toBeNull();
         expect(response.allValidationOutputs().length).toBe(0);
     });
-});
 
+    it('validates architecture against schema specified in $schema property when no pattern provided', async () => {
+        const expectedSpectralOutput: ISpectralDiagnostic[] = [];
+        mockRunFunction.mockReturnValue(expectedSpectralOutput);
+
+        // Create a simple valid architecture with a CALM schema reference
+        const validArchitecture = {
+            '$schema': 'https://raw.githubusercontent.com/finos/architecture-as-code/main/calm/draft/2024-03/meta/calm.json',
+            'nodes': [
+                {
+                    'unique-id': 'test-node',
+                    'node-type': 'system',
+                    'name': 'Test Node',
+                    'description': 'A test node'
+                }
+            ],
+            'relationships': []
+        };
+
+        fetchMock.mockGlobal().route('http://exist/valid-architecture.json', JSON.stringify(validArchitecture));
+        
+        // Mock the CALM schema
+        const calmSchema = readFileSync(path.resolve(__dirname, '../../../test_fixtures/calm/calm.json'), 'utf8');
+        fetchMock.mockGlobal().route('https://raw.githubusercontent.com/finos/architecture-as-code/main/calm/draft/2024-03/meta/calm.json', calmSchema);
+
+        // Mock the core schema
+        const coreSchema = readFileSync(path.resolve(__dirname, '../../../test_fixtures/calm/core.json'), 'utf8');
+        fetchMock.mockGlobal().route('https://raw.githubusercontent.com/finos/architecture-as-code/main/calm/draft/2024-03/meta/core.json', coreSchema);
+
+        const response = await validate('http://exist/valid-architecture.json', '', metaSchemaLocation, false);
+        
+        expect(response).not.toBeNull();
+        expect(response).not.toBeUndefined();
+        
+        // For a valid architecture, we should not have errors
+        expect(response.hasErrors).toBeFalsy();
+        expect(response.hasWarnings).toBeFalsy();
+    });
+});
 
 function buildISpectralDiagnostic(code: string, message: string, severity: number): ISpectralDiagnostic {
     return {

shared/src/commands/validate/validate.ts

@@ -138,7 +138,7 @@ export async function validate(
         } else if (jsonSchemaLocation) {
             return await validatePatternOnly(jsonSchemaLocation, metaSchemaPath, debug);
         } else if (jsonSchemaArchitectureLocation) {
-            return await validateArchitectureOnly(jsonSchemaArchitectureLocation);
+            return await validateArchitectureOnly(jsonSchemaArchitectureLocation, metaSchemaPath, debug);
         } else {
             logger.debug('You must provide at least an architecture or a pattern');
             throw new Error('You must provide at least an architecture or a pattern');
@@ -221,16 +221,87 @@ async function validatePatternOnly(jsonSchemaLocation: string, metaSchemaPath: s
 
 /**
  * Run the spectral validations for the case where only the architecture is provided.
+ * When no pattern is provided, validate the architecture against the CALM schema specified in its $schema property.
  * 
  * @param architectureSchemaLocation - The location of the architecture schema.
- * @returns the validation outcome with the results of the spectral validation.
+ * @param metaSchemaPath - The path of the meta schemas to use for ajv (optional).
+ * @param debug - The flag to enable debug logging (optional).
+ * @returns the validation outcome with the results of the spectral validation and JSON schema validation.
  */
-async function validateArchitectureOnly(architectureSchemaLocation: string): Promise<ValidationOutcome> {
-    logger.debug('Pattern was not provided, only the Architecture will be validated');
+async function validateArchitectureOnly(architectureSchemaLocation: string, metaSchemaPath?: string, debug: boolean = false): Promise<ValidationOutcome> {
+    logger.debug('Pattern was not provided, validating Architecture against its specified CALM schema');
 
     const jsonSchemaArchitecture = await getFileFromUrlOrPath(architectureSchemaLocation);
-    const spectralResultForArchitecture: SpectralResult = await runSpectralValidations(jsonSchemaArchitecture, validationRulesForArchitecture); 
-    return new ValidationOutcome([], spectralResultForArchitecture.spectralIssues, spectralResultForArchitecture.errors, spectralResultForArchitecture.warnings);
+    const spectralResultForArchitecture: SpectralResult = await runSpectralValidations(jsonSchemaArchitecture, validationRulesForArchitecture);
+    
+    let jsonSchemaValidations = [];
+    let errors = spectralResultForArchitecture.errors;
+    const warnings = spectralResultForArchitecture.warnings;
+    
+    logger.debug(`metaSchemaPath provided: ${metaSchemaPath}`);
+    
+    // If metaSchemaPath is provided, attempt to validate against the CALM schema specified in the architecture
+    if (metaSchemaPath) {
+        logger.debug('Attempting CALM schema validation');
+        try {
+            const architectureObj = typeof jsonSchemaArchitecture === 'string' ? JSON.parse(jsonSchemaArchitecture) : jsonSchemaArchitecture;
+            const schemaUrl = architectureObj.$schema;
+            
+            logger.debug(`Parsed architecture object, $schema: ${schemaUrl}`);
+            
+            if (schemaUrl) {
+                logger.debug(`Found $schema reference: ${schemaUrl}`);
+                logger.debug('Validating architecture against its specified CALM schema');
+                
+                const schemaDirectory = await loadMetaSchemas(metaSchemaPath, debug);
+                const ajv = buildAjv2020(schemaDirectory, debug);
+                
+                // Load the schema from the URL specified in the architecture
+                logger.debug(`Loading schema from: ${schemaUrl}`);
+                
+                // For schema loading, we need to handle both URL and local file cases
+                let calmSchemaObject;
+                const urlPattern = /^https?:\/\//;
+                if (urlPattern.test(schemaUrl)) {
+                    const content = await loadFileFromUrl(schemaUrl);
+                    calmSchemaObject = typeof content === 'string' ? JSON.parse(content) : content;
+                } else {
+                    // For local files, read as raw string and parse
+                    if (!existsSync(schemaUrl)) {
+                        throw new Error(`Schema file could not be found at ${schemaUrl}`);
+                    }
+                    const rawContent = await fs.readFile(schemaUrl, 'utf-8');
+                    calmSchemaObject = JSON.parse(rawContent);
+                }
+                
+                logger.debug('Loaded schema object');
+                
+                const validateSchema = await ajv.compileAsync(calmSchemaObject);
+                
+                logger.debug('Compiled schema, running validation');
+                const validationResult = validateSchema(architectureObj);
+                logger.debug(`Validation result: ${validationResult}`);
+                
+                if (!validationResult) {
+                    logger.debug(`JSON Schema validation raw output: ${prettifyJson(validateSchema.errors)}`);
+                    errors = true;
+                    jsonSchemaValidations = convertJsonSchemaIssuesToValidationOutputs(validateSchema.errors);
+                    logger.debug(`Converted ${jsonSchemaValidations.length} validation errors`);
+                }
+            } else {
+                logger.debug('No $schema property found in architecture document, skipping CALM schema validation');
+            }
+        } catch (error) {
+            logger.debug(`Error during CALM schema validation: ${error.message}`);
+            logger.debug(`Error stack: ${error.stack}`);
+            // Don't fail the entire validation if schema validation fails - just log and continue with spectral validation
+        }
+    } else {
+        logger.debug('No metaSchemaPath provided, skipping CALM schema validation');
+    }
+    
+    logger.debug(`Returning validation outcome with ${jsonSchemaValidations.length} JSON schema validations, errors: ${errors}`);
+    return new ValidationOutcome(jsonSchemaValidations, spectralResultForArchitecture.spectralIssues, errors, warnings);
 }
 
 function extractSpectralRuleNames(): string[] {