@ai-setting/roy-agent-core 1.3.9 → 1.3.11

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

@@ -1,133 +0,0 @@
-/**
- * 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

@@ -1,71 +0,0 @@
-/**
- * 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

@@ -1,310 +0,0 @@
-/**
- * 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);
-    });
-  });
-});