@principal-ai/principal-view-core 0.28.1 → 0.28.3

package/src/workflow/__tests__/validator.test.ts

@@ -7,6 +7,7 @@ import type { WorkflowTemplate, WorkflowValidationContext } from '../validator';
 import type { ExtendedCanvas } from '../../types/canvas';
 import type { ComponentLibrary } from '../../types/library';
 import { EventRegistry } from '../../registry/EventRegistry';
+import { NodeFileSystemAdapter } from '@principal-ai/repository-abstraction/node';
 import { mkdtempSync, writeFileSync, rmSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
@@ -16,7 +17,7 @@ describe('WorkflowValidator', () => {
   let tempDir: string;
 
   beforeEach(() => {
-    validator = new WorkflowValidator();
+    validator = new WorkflowValidator(new NodeFileSystemAdapter());
     // Create a temporary directory for test files
     tempDir = mkdtempSync(join(tmpdir(), 'workflow-validator-test-'));
   });
@@ -303,6 +304,124 @@ describe('WorkflowValidator', () => {
     });
   });
 
+  // ============================================================================
+  // Implementation Files Existence Tests (workflow-files-exist)
+  // ============================================================================
+
+  describe('workflow-files-exist', () => {
+    // Create the referenced canvas so unrelated canvas-exists violations stay silent.
+    function setupCanvas(): string {
+      const canvasPath = join(tempDir, 'test.otel.canvas');
+      writeFileSync(canvasPath, JSON.stringify(createValidCanvas()));
+      writeFileSync(join(tempDir, 'test.md'), '# Test');
+      return canvasPath;
+    }
+
+    it('should pass when status is implemented and all files exist', async () => {
+      const canvasPath = setupCanvas();
+      writeFileSync(join(tempDir, 'impl.ts'), '// impl');
+
+      const context = createContext(
+        { status: 'implemented', scope: 'test-scope', files: ['impl.ts'] },
+        { canvasPath }
+      );
+      const result = await validator.validate(context);
+
+      const fileViolations = result.violations.filter(
+        (v) => v.ruleId === 'workflow-files-exist'
+      );
+      expect(fileViolations).toHaveLength(0);
+    });
+
+    it('should flag each missing file when status is implemented', async () => {
+      const canvasPath = setupCanvas();
+
+      const context = createContext(
+        {
+          status: 'implemented',
+          scope: 'test-scope',
+          files: ['missing-one.ts', 'missing-two.ts'],
+        },
+        { canvasPath }
+      );
+      const result = await validator.validate(context);
+
+      const fileViolations = result.violations.filter(
+        (v) => v.ruleId === 'workflow-files-exist'
+      );
+      expect(fileViolations).toHaveLength(2);
+      expect(fileViolations).toContainEqual(
+        expect.objectContaining({
+          ruleId: 'workflow-files-exist',
+          severity: 'error',
+          path: 'files',
+          message: expect.stringContaining('missing-one.ts'),
+        })
+      );
+      expect(fileViolations).toContainEqual(
+        expect.objectContaining({
+          ruleId: 'workflow-files-exist',
+          message: expect.stringContaining('missing-two.ts'),
+        })
+      );
+    });
+
+    it('should flag only the missing files when some exist and some do not', async () => {
+      const canvasPath = setupCanvas();
+      writeFileSync(join(tempDir, 'present.ts'), '// present');
+
+      const context = createContext(
+        {
+          status: 'implemented',
+          scope: 'test-scope',
+          files: ['present.ts', 'absent.ts'],
+        },
+        { canvasPath }
+      );
+      const result = await validator.validate(context);
+
+      const fileViolations = result.violations.filter(
+        (v) => v.ruleId === 'workflow-files-exist'
+      );
+      expect(fileViolations).toHaveLength(1);
+      expect(fileViolations[0].message).toContain('absent.ts');
+    });
+
+    it('should not check file existence when status is draft', async () => {
+      const canvasPath = setupCanvas();
+
+      const context = createContext(
+        { status: 'draft', files: ['does-not-exist.ts'] },
+        { canvasPath }
+      );
+      const result = await validator.validate(context);
+
+      const fileViolations = result.violations.filter(
+        (v) => v.ruleId === 'workflow-files-exist'
+      );
+      expect(fileViolations).toHaveLength(0);
+    });
+
+    it('should not check file existence when status is approved', async () => {
+      const canvasPath = setupCanvas();
+
+      const context = createContext(
+        {
+          status: 'approved',
+          scope: 'test-scope',
+          files: ['does-not-exist.ts'],
+        },
+        { canvasPath }
+      );
+      const result = await validator.validate(context);
+
+      const fileViolations = result.violations.filter(
+        (v) => v.ruleId === 'workflow-files-exist'
+      );
+      expect(fileViolations).toHaveLength(0);
+    });
+  });
+
   // ============================================================================
   // Scenario Validation Tests
   // ============================================================================

package/src/workflow/validator.ts

@@ -3,11 +3,11 @@
  * Validates .workflow.json files against their corresponding .otel.canvas files
  */
 
+import type { FileSystemAdapter } from '@principal-ai/repository-abstraction';
 import type { WorkflowTemplate, WorkflowScenario, ScenarioTemplate } from './types';
 import { getEventTemplateString } from './types';
 import type { ExtendedCanvas, OtelEventNode } from '../types/canvas';
 import { isOtelEventNode } from '../types/canvas';
-import { existsSync, readFileSync } from 'fs';
 import { resolve, basename } from 'path';
 import type { EventRegistry } from '../registry/EventRegistry';
 import type { IExportTraceServiceRequest } from '@opentelemetry/otlp-transformer/build/src/trace/internal-types';
@@ -125,6 +125,8 @@ export interface WorkflowValidationResult {
 // ============================================================================
 
 export class WorkflowValidator {
+  constructor(private fsAdapter: FileSystemAdapter) {}
+
   /**
    * Validate a workflow template
    */
@@ -134,8 +136,8 @@ export class WorkflowValidator {
     const violations: WorkflowViolation[] = [];
 
     // Run all validation rules
-    violations.push(...this.checkSchema(context));
-    violations.push(...this.checkCanvasExists(context));
+    violations.push(...(await this.checkSchema(context)));
+    violations.push(...(await this.checkCanvasExists(context)));
     violations.push(...this.checkCanvasNodeLabels(context));
     violations.push(...this.checkCanvasCrossReference(context));
     violations.push(...this.checkDeprecatedFields(context));
@@ -162,7 +164,7 @@ export class WorkflowValidator {
 
     // Check execution data completeness if execution files are provided
     if (context.executionFiles && context.executionFiles.length > 0) {
-      violations.push(...this.checkExecutionDataCompleteness(context));
+      violations.push(...(await this.checkExecutionDataCompleteness(context)));
     }
 
     return this.aggregateResults(violations);
@@ -221,7 +223,7 @@ export class WorkflowValidator {
   /**
    * Check schema validity (required fields, valid values)
    */
-  private checkSchema(context: WorkflowValidationContext): WorkflowViolation[] {
+  private async checkSchema(context: WorkflowValidationContext): Promise<WorkflowViolation[]> {
     const violations: WorkflowViolation[] = [];
     const { workflow, workflowPath } = context;
 
@@ -426,7 +428,7 @@ export class WorkflowValidator {
     if (status === 'implemented' && workflow.files && workflow.files.length > 0) {
       for (const file of workflow.files) {
         const filePath = resolve(context.basePath, file);
-        if (!existsSync(filePath)) {
+        if (!(await this.fsAdapter.exists(filePath))) {
           violations.push({
             ruleId: 'workflow-files-exist',
             severity: 'error',
@@ -501,7 +503,7 @@ export class WorkflowValidator {
   /**
    * Check that the referenced canvas file exists
    */
-  private checkCanvasExists(context: WorkflowValidationContext): WorkflowViolation[] {
+  private async checkCanvasExists(context: WorkflowValidationContext): Promise<WorkflowViolation[]> {
     const violations: WorkflowViolation[] = [];
     const { workflow, workflowPath, basePath, canvasPath } = context;
 
@@ -513,7 +515,7 @@ export class WorkflowValidator {
     // Resolve canvas path
     const resolvedPath = canvasPath || resolve(basePath, workflow.canvas);
 
-    if (!existsSync(resolvedPath)) {
+    if (!(await this.fsAdapter.exists(resolvedPath))) {
       violations.push({
         ruleId: 'workflow-canvas-exists',
         severity: 'error',
@@ -2302,7 +2304,7 @@ export class WorkflowValidator {
    * Validates that co-located execution files contain the events and attributes
    * that workflow templates reference.
    */
-  private checkExecutionDataCompleteness(context: WorkflowValidationContext): WorkflowViolation[] {
+  private async checkExecutionDataCompleteness(context: WorkflowValidationContext): Promise<WorkflowViolation[]> {
     const violations: WorkflowViolation[] = [];
     const { workflow, workflowPath, executionFiles } = context;
 
@@ -2314,7 +2316,7 @@ export class WorkflowValidator {
     const executions: Array<{path: string; data: IExportTraceServiceRequest}> = [];
     for (const execPath of executionFiles) {
       try {
-        const content = readFileSync(execPath, 'utf-8');
+        const content = await this.fsAdapter.readFile(execPath);
         const data = JSON.parse(content) as IExportTraceServiceRequest;
         executions.push({ path: execPath, data });
       } catch (error) {
@@ -2730,6 +2732,6 @@ export class WorkflowValidator {
 /**
  * Create a validator instance
  */
-export function createWorkflowValidator(): WorkflowValidator {
-  return new WorkflowValidator();
+export function createWorkflowValidator(fsAdapter: FileSystemAdapter): WorkflowValidator {
+  return new WorkflowValidator(fsAdapter);
 }