@ai-setting/roy-agent-core 1.0.0

package/src/env/workflow/service/registry.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Registry Tests
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { WorkflowServiceRegistry, registerWorkflowService, getWorkflowService } from './registry';
+import { WorkflowService } from './workflow-service';
+import { MockWorkflowRepository, MockRunRepository, MockWorkflowEngine } from '../storage/mock-repositories';
+
+describe('WorkflowServiceRegistry', () => {
+  let mockEngine: MockWorkflowEngine;
+  
+  beforeEach(() => {
+    // Reset registry before each test
+    WorkflowServiceRegistry.getInstance().reset();
+    mockEngine = new MockWorkflowEngine();
+  });
+  
+  const createService = () => new WorkflowService(
+    new MockWorkflowRepository(),
+    new MockRunRepository(),
+    (workflow, options) => mockEngine as any
+  );
+  
+  describe('getInstance', () => {
+    it('should return the same instance on multiple calls', () => {
+      const instance1 = WorkflowServiceRegistry.getInstance();
+      const instance2 = WorkflowServiceRegistry.getInstance();
+      
+      expect(instance1).toBe(instance2);
+    });
+  });
+  
+  describe('register', () => {
+    it('should register a service', () => {
+      const registry = WorkflowServiceRegistry.getInstance();
+      const service = createService();
+      
+      registry.register(service);
+      
+      expect(registry.isRegistered()).toBe(true);
+    });
+  });
+  
+  describe('get', () => {
+    it('should return the registered service', () => {
+      const registry = WorkflowServiceRegistry.getInstance();
+      const service = createService();
+      
+      registry.register(service);
+      
+      expect(registry.get()).toBe(service);
+    });
+    
+    it('should throw error if no service registered', () => {
+      const registry = WorkflowServiceRegistry.getInstance();
+      
+      expect(() => registry.get()).toThrow('WorkflowService is not registered');
+    });
+  });
+  
+  describe('isRegistered', () => {
+    it('should return false if no service registered', () => {
+      const registry = WorkflowServiceRegistry.getInstance();
+      
+      expect(registry.isRegistered()).toBe(false);
+    });
+    
+    it('should return true after service is registered', () => {
+      const registry = WorkflowServiceRegistry.getInstance();
+      const service = new WorkflowService(
+        new MockWorkflowRepository(),
+        new MockRunRepository(),
+        mockEngine as any
+      );
+      
+      registry.register(service);
+      
+      expect(registry.isRegistered()).toBe(true);
+    });
+  });
+  
+  describe('reset', () => {
+    it('should reset the registry', () => {
+      const registry = WorkflowServiceRegistry.getInstance();
+      const service = createService();
+      
+      registry.register(service);
+      registry.reset();
+      
+      expect(registry.isRegistered()).toBe(false);
+    });
+  });
+});
+
+describe('convenience functions', () => {
+  let mockEngine: MockWorkflowEngine;
+  
+  beforeEach(() => {
+    WorkflowServiceRegistry.getInstance().reset();
+    mockEngine = new MockWorkflowEngine();
+  });
+  
+  const createService = () => new WorkflowService(
+    new MockWorkflowRepository(),
+    new MockRunRepository(),
+    (workflow, options) => mockEngine as any
+  );
+  
+  describe('registerWorkflowService', () => {
+    it('should register service via convenience function', () => {
+      const service = createService();
+      
+      registerWorkflowService(service);
+      
+      expect(WorkflowServiceRegistry.getInstance().isRegistered()).toBe(true);
+    });
+  });
+  
+  describe('getWorkflowService', () => {
+    it('should get service via convenience function', () => {
+      const service = createService();
+      
+      registerWorkflowService(service);
+      
+      expect(getWorkflowService()).toBe(service);
+    });
+    
+    it('should throw if service not registered', () => {
+      expect(() => getWorkflowService()).toThrow('WorkflowService is not registered');
+    });
+  });
+});

package/src/env/workflow/service/registry.ts

@@ -0,0 +1,71 @@
+/**
+ * Registry - Singleton registry for accessing WorkflowService
+ */
+
+import { WorkflowService } from './workflow-service';
+
+/**
+ * Singleton registry for WorkflowService
+ * Provides centralized access to the workflow service instance
+ */
+export class WorkflowServiceRegistry {
+  private static instance: WorkflowServiceRegistry;
+  private service: WorkflowService | null = null;
+  
+  private constructor() {}
+  
+  /**
+   * Get the singleton registry instance
+   */
+  static getInstance(): WorkflowServiceRegistry {
+    if (!WorkflowServiceRegistry.instance) {
+      WorkflowServiceRegistry.instance = new WorkflowServiceRegistry();
+    }
+    return WorkflowServiceRegistry.instance;
+  }
+  
+  /**
+   * Register a WorkflowService instance
+   */
+  register(service: WorkflowService): void {
+    this.service = service;
+  }
+  
+  /**
+   * Get the registered WorkflowService instance
+   * @throws Error if no service is registered
+   */
+  get(): WorkflowService {
+    if (!this.service) {
+      throw new Error('WorkflowService is not registered. Call register() first.');
+    }
+    return this.service;
+  }
+  
+  /**
+   * Check if a service is registered
+   */
+  isRegistered(): boolean {
+    return this.service !== null;
+  }
+  
+  /**
+   * Reset the registry (primarily for testing)
+   */
+  reset(): void {
+    this.service = null;
+  }
+}
+
+// Convenience function to get the service
+export function getWorkflowService(): WorkflowService {
+  return WorkflowServiceRegistry.getInstance().get();
+}
+
+// Convenience function to register the service
+export function registerWorkflowService(service: WorkflowService): void {
+  WorkflowServiceRegistry.getInstance().register(service);
+}
+
+// Type for the registry
+export type { WorkflowService };

package/src/env/workflow/service/workflow-service.test.ts

@@ -0,0 +1,310 @@
+/**
+ * WorkflowService Tests - Session-based Design
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'bun:test';
+import { WorkflowService } from './workflow-service';
+import { MockWorkflowRepository, MockWorkflowEngine } from '../storage/mock-repositories';
+import type { WorkflowDefinition, Workflow } from '../types';
+
+describe('WorkflowService', () => {
+  let workflowRepo: MockWorkflowRepository;
+  let mockEngine: MockWorkflowEngine;
+  let service: WorkflowService;
+  
+  const sampleDefinition: WorkflowDefinition = {
+    name: 'test-workflow',
+    version: '1.0',
+    description: 'A test workflow',
+    nodes: [
+      {
+        id: 'node1',
+        type: 'tool',
+        config: { tool: 'test-tool' },
+      },
+      {
+        id: 'node2',
+        type: 'tool',
+        config: { tool: 'test-tool-2' },
+        depends_on: ['node1'],
+      },
+    ],
+  };
+  
+  beforeEach(() => {
+    workflowRepo = new MockWorkflowRepository();
+    mockEngine = new MockWorkflowEngine();
+    
+    // Create engine factory that returns the mock engine
+    const engineFactory = (workflow: Workflow) => {
+      mockEngine.setWorkflowName(workflow.name);
+      return mockEngine as any;
+    };
+    
+    service = new WorkflowService(
+      workflowRepo,
+      engineFactory
+    );
+  });
+
+  // ==================== Workflow CRUD Tests ====================
+  
+  describe('createWorkflow', () => {
+    it('should create a workflow from definition', async () => {
+      const workflow = await service.createWorkflow(sampleDefinition);
+      
+      expect(workflow).toBeDefined();
+      expect(workflow.name).toBe('test-workflow');
+      expect(workflow.version).toBe('1.0');
+      expect(workflow.definition).toEqual(sampleDefinition);
+      expect(workflow.id).toBeDefined();
+    });
+    
+    it('should create workflow with tags from options', async () => {
+      const workflow = await service.createWorkflow(sampleDefinition, {
+        tags: ['test', 'example'],
+      });
+      
+      expect(workflow.tags).toEqual(['test', 'example']);
+    });
+    
+    it('should create workflow with metadata from options', async () => {
+      const workflow = await service.createWorkflow(sampleDefinition, {
+        metadata: { author: 'tester' },
+      });
+      
+      expect(workflow.metadata.author).toBe('tester');
+    });
+    
+    it('should throw error if workflow with same name exists', async () => {
+      await service.createWorkflow(sampleDefinition);
+      
+      await expect(service.createWorkflow(sampleDefinition)).rejects.toThrow(
+        'Workflow already exists'
+      );
+    });
+    
+    it('should allow creating workflow with force option to overwrite', async () => {
+      await service.createWorkflow(sampleDefinition);
+      
+      const updatedDef = { ...sampleDefinition, description: 'Updated' };
+      const workflow = await service.createWorkflow(updatedDef, { force: true });
+      
+      expect(workflow.description).toBe('Updated');
+    });
+  });
+
+  describe('getWorkflow', () => {
+    it('should get workflow by id', async () => {
+      const created = await service.createWorkflow(sampleDefinition);
+      
+      const workflow = service.getWorkflow(created.id);
+      
+      expect(workflow).toBeDefined();
+      expect(workflow?.name).toBe('test-workflow');
+    });
+    
+    it('should get workflow by name', () => {
+      service.createWorkflow(sampleDefinition);
+      
+      const workflow = service.getWorkflow('test-workflow');
+      
+      expect(workflow).toBeDefined();
+      expect(workflow?.id).toBeDefined();
+    });
+    
+    it('should return null if workflow not found', () => {
+      const workflow = service.getWorkflow('nonexistent');
+      
+      expect(workflow).toBeNull();
+    });
+  });
+
+  describe('listWorkflows', () => {
+    it('should list all workflows', async () => {
+      await service.createWorkflow(sampleDefinition);
+      await service.createWorkflow({
+        ...sampleDefinition,
+        name: 'workflow2',
+      });
+      
+      const workflows = service.listWorkflows();
+      
+      expect(workflows.length).toBeGreaterThanOrEqual(2);
+    });
+    
+    it('should filter workflows by tag', async () => {
+      await service.createWorkflow(sampleDefinition, { tags: ['test'] });
+      await service.createWorkflow({
+        ...sampleDefinition,
+        name: 'workflow2',
+      }, { tags: ['other'] });
+      
+      const workflows = service.listWorkflows({ tag: 'test' });
+      
+      expect(workflows.length).toBeGreaterThanOrEqual(1);
+      expect(workflows.every(w => w.tags.includes('test'))).toBe(true);
+    });
+    
+    it('should support pagination with limit and offset', async () => {
+      for (let i = 0; i < 5; i++) {
+        await service.createWorkflow({
+          ...sampleDefinition,
+          name: `workflow${i}`,
+        });
+      }
+      
+      const workflows = service.listWorkflows({ limit: 2, offset: 0 });
+      
+      expect(workflows.length).toBeLessThanOrEqual(2);
+    });
+  });
+
+  describe('updateWorkflow', () => {
+    it('should update workflow definition', async () => {
+      await service.createWorkflow(sampleDefinition);
+      
+      const updatedDef = {
+        ...sampleDefinition,
+        nodes: [
+          ...sampleDefinition.nodes,
+          { id: 'new-node', type: 'tool', config: { tool: 'new-tool' } },
+        ],
+      };
+      
+      const workflow = await service.updateWorkflow('test-workflow', {
+        definition: updatedDef,
+      });
+      
+      expect(workflow.definition.nodes.length).toBe(3);
+    });
+    
+    it('should update workflow tags', async () => {
+      await service.createWorkflow(sampleDefinition);
+      
+      const workflow = await service.updateWorkflow('test-workflow', {}, {
+        tags: ['updated', 'tags'],
+      });
+      
+      expect(workflow.tags).toEqual(['updated', 'tags']);
+    });
+    
+    it('should throw error if workflow not found', async () => {
+      await expect(
+        service.updateWorkflow('nonexistent', { definition: sampleDefinition })
+      ).rejects.toThrow('Workflow not found');
+    });
+  });
+
+  describe('deleteWorkflow', () => {
+    it('should delete workflow by name', async () => {
+      await service.createWorkflow(sampleDefinition);
+      
+      const result = await service.deleteWorkflow('test-workflow');
+      
+      expect(result).toBe(true);
+      expect(service.getWorkflow('test-workflow')).toBeNull();
+    });
+    
+    it('should return false if workflow not found', async () => {
+      const result = await service.deleteWorkflow('nonexistent');
+      
+      expect(result).toBe(false);
+    });
+  });
+
+  // ==================== Workflow Execution Tests (Session-based) ====================
+  
+  describe('runWorkflow', () => {
+    it('should run workflow by definition', async () => {
+      await service.createWorkflow(sampleDefinition);
+      
+      const result = await service.runWorkflow(sampleDefinition);
+      
+      expect(result).toBeDefined();
+      expect(result.sessionId || result.runId).toBeDefined();
+      expect(mockEngine.getCallsByMethod('runWorkflow')).toHaveLength(1);
+    });
+    
+    it('should pass input to workflow run', async () => {
+      await service.createWorkflow(sampleDefinition);
+      
+      const result = await service.runWorkflow(sampleDefinition, {
+        key: 'value',
+      });
+      
+      expect(result).toBeDefined();
+      const runCall = mockEngine.getCallsByMethod('runWorkflow')[0];
+      expect(runCall.args[1]).toBeDefined();
+    });
+    
+    it('should run workflow by name', async () => {
+      await service.createWorkflow(sampleDefinition);
+      
+      const result = await service.runWorkflow('test-workflow');
+      
+      expect(result).toBeDefined();
+      expect(result.sessionId || result.runId).toBeDefined();
+    });
+  });
+
+  describe('runWorkflowByName', () => {
+    it('should run workflow by name and return result', async () => {
+      await service.createWorkflow(sampleDefinition);
+      
+      const result = await service.runWorkflowByName('test-workflow', { test: 'input' });
+      
+      expect(result).toBeDefined();
+      expect(result.sessionId || result.runId).toBeDefined();
+      expect(mockEngine.getLastCall()?.method).toBe('runWorkflow');
+    });
+    
+    it('should throw error if workflow not found', async () => {
+      await expect(
+        service.runWorkflowByName('nonexistent')
+      ).rejects.toThrow('Workflow not found');
+    });
+  });
+
+  // ==================== Session-based Lifecycle Tests ====================
+  
+  describe('Session-based Resume', () => {
+    it('should have engine factory that creates new engine for each resume', async () => {
+      await service.createWorkflow(sampleDefinition);
+      
+      // Create a mock session component
+      const mockSessionComponent = {
+        create: vi.fn().mockResolvedValue({ id: 'workflow_test_123' }),
+        get: vi.fn().mockResolvedValue({
+          id: 'workflow_test_123',
+          metadata: {
+            type: 'workflow',
+            workflowName: 'test-workflow',
+            status: 'paused',
+          },
+        }),
+        update: vi.fn().mockResolvedValue(true),
+        addMessage: vi.fn().mockResolvedValue('msg_id'),
+        getMessages: vi.fn().mockResolvedValue([]),
+      };
+      
+      // Create service with session component
+      const engineFactory = (workflow: Workflow) => {
+        mockEngine.setWorkflowName(workflow.name);
+        return mockEngine as any;
+      };
+      
+      const serviceWithSession = new WorkflowService(
+        workflowRepo,
+        engineFactory,
+        mockSessionComponent
+      );
+      
+      // Run workflow first
+      const result = await serviceWithSession.runWorkflow('test-workflow');
+      
+      // Verify engine was created
+      expect(mockEngine.getCallsByMethod('runWorkflow')).toHaveLength(1);
+    });
+  });
+});