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

package/src/env/workflow/storage/mock-repositories.ts

@@ -1,385 +0,0 @@
-/**
- * Mock Repositories for Testing
- * 
- * Note: After session-based refactoring, workflow runs are managed via SessionComponent.
- * These mock repositories only handle workflow definitions.
- */
-
-import type { Workflow, WorkflowRun, RunStatus } from '../types';
-
-// ==================== Mock RunRepository ====================
-
-export interface MockRunRepositoryOptions {
-  workflowId?: string;
-  workflowName?: string;
-}
-
-export class MockRunRepository {
-  private runs: Map<string, WorkflowRun> = new Map();
-  private options: MockRunRepositoryOptions;
-  
-  constructor(options: MockRunRepositoryOptions = {}) {
-    this.options = options;
-  }
-  
-  setWorkflowInfo(workflowId: string, workflowName: string): void {
-    this.options.workflowId = workflowId;
-    this.options.workflowName = workflowName;
-  }
-  
-  createWorkflowRun(run: Omit<WorkflowRun, 'id'>): WorkflowRun {
-    const id = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    
-    const created: WorkflowRun = {
-      ...run,
-      id,
-    };
-    
-    this.runs.set(id, created);
-    return created;
-  }
-  
-  getWorkflowRun(id: string): WorkflowRun | null {
-    return this.runs.get(id) || null;
-  }
-  
-  listWorkflowRuns(workflowId?: string, options?: { status?: RunStatus }): WorkflowRun[] {
-    let runs = Array.from(this.runs.values());
-    
-    if (workflowId) {
-      runs = runs.filter(r => r.workflowId === workflowId);
-    }
-    
-    if (options?.status) {
-      runs = runs.filter(r => r.status === options.status);
-    }
-    
-    // Sort by startedAt descending
-    runs.sort((a, b) => {
-      const aTime = a.startedAt?.getTime() || 0;
-      const bTime = b.startedAt?.getTime() || 0;
-      return bTime - aTime;
-    });
-    
-    return runs;
-  }
-  
-  updateWorkflowRun(id: string, updates: Partial<WorkflowRun>): WorkflowRun | null {
-    const existing = this.runs.get(id);
-    if (!existing) return null;
-    
-    const updated: WorkflowRun = {
-      ...existing,
-      ...updates,
-    };
-    
-    this.runs.set(id, updated);
-    return updated;
-  }
-  
-  // Helper for testing
-  clear(): void {
-    this.runs.clear();
-  }
-  
-  count(): number {
-    return this.runs.size;
-  }
-  
-  // Helper for MockWorkflowEngine
-  setWorkflowName(name: string): void {
-    this.options.workflowName = name;
-  }
-}
-
-// ==================== Mock WorkflowRepository ====================
-
-export class MockWorkflowRepository {
-  private workflows: Map<string, Workflow> = new Map();
-  private nameIndex: Map<string, string> = new Map(); // name -> id
-  
-  create(workflow: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'>): Workflow {
-    const id = `wf_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    const now = new Date();
-    
-    const created: Workflow = {
-      ...workflow,
-      id,
-      createdAt: now,
-      updatedAt: now,
-    };
-    
-    this.workflows.set(id, created);
-    this.nameIndex.set(created.name, id);
-    
-    return created;
-  }
-  
-  getById(id: string): Workflow | null {
-    return this.workflows.get(id) || null;
-  }
-  
-  getByName(name: string): Workflow | null {
-    const id = this.nameIndex.get(name);
-    return id ? this.workflows.get(id) || null : null;
-  }
-  
-  list(options?: { tag?: string; limit?: number; offset?: number }): Workflow[] {
-    let workflows = Array.from(this.workflows.values());
-    
-    if (options?.tag) {
-      workflows = workflows.filter(w => w.tags.includes(options.tag!));
-    }
-    
-    // Sort by updatedAt descending
-    workflows.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
-    
-    if (options?.offset) {
-      workflows = workflows.slice(options.offset);
-    }
-    
-    if (options?.limit) {
-      workflows = workflows.slice(0, options.limit);
-    }
-    
-    return workflows;
-  }
-  
-  update(id: string, updates: Partial<Workflow>): Workflow | null {
-    const existing = this.workflows.get(id);
-    if (!existing) return null;
-    
-    const updated: Workflow = {
-      ...existing,
-      ...updates,
-      id, // Ensure ID doesn't change
-      updatedAt: new Date(),
-    };
-    
-    // Update name index if name changed
-    if (updates.name && updates.name !== existing.name) {
-      this.nameIndex.delete(existing.name);
-      this.nameIndex.set(updated.name, id);
-    }
-    
-    this.workflows.set(id, updated);
-    return updated;
-  }
-  
-  delete(id: string): boolean {
-    const workflow = this.workflows.get(id);
-    if (!workflow) return false;
-    
-    this.workflows.delete(id);
-    this.nameIndex.delete(workflow.name);
-    return true;
-  }
-  
-  exists(name: string): boolean {
-    return this.nameIndex.has(name);
-  }
-  
-  // Helper for testing
-  clear(): void {
-    this.workflows.clear();
-    this.nameIndex.clear();
-  }
-  
-  // Helper to get count
-  count(): number {
-    return this.workflows.size;
-  }
-}
-
-// ==================== Mock WorkflowEngine ====================
-
-export interface MockEngineCall {
-  method: string;
-  args: any[];
-  result?: any;
-  timestamp: number;
-}
-
-// Factory type for creating mock engines
-export type MockEngineFactory = () => MockWorkflowEngine;
-
-export class MockWorkflowEngine {
-  calls: MockEngineCall[] = [];
-  private sessionResults: Map<string, any> = new Map();
-  private workflowName: string = '';
-  
-  constructor() {
-    // No longer takes runRepository parameter
-  }
-  
-  setWorkflowName(name: string): void {
-    this.workflowName = name;
-  }
-  
-  getWorkflowName(): string {
-    return this.workflowName;
-  }
-  
-  async createSession(
-    workflowId: string,
-    options?: { input?: Record<string, any>; workflowName?: string; workflowVersion?: string }
-  ): Promise<string> {
-    this.calls.push({
-      method: 'createSession',
-      args: [workflowId, options],
-      timestamp: Date.now(),
-    });
-    
-    const sessionId = `workflow_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    this.sessionResults.set(sessionId, {
-      status: 'running',
-      output: null,
-    });
-    
-    return sessionId;
-  }
-  
-  async createRun(
-    workflowNameOrDefinition: string | any,
-    options?: { input?: Record<string, any>; debug?: boolean }
-  ): Promise<string> {
-    this.calls.push({
-      method: 'createRun',
-      args: [workflowNameOrDefinition, options],
-      timestamp: Date.now(),
-    });
-    
-    const runId = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    this.sessionResults.set(runId, {
-      status: 'idle',
-      output: null,
-    });
-    
-    return runId;
-  }
-  
-  async run(runId: string, options?: any): Promise<any> {
-    this.calls.push({
-      method: 'run',
-      args: [runId, options],
-      timestamp: Date.now(),
-    });
-    
-    const isSync = options?.sync ?? true;
-    
-    this.sessionResults.set(runId, {
-      status: isSync ? 'completed' : 'running',
-      output: { result: 'mocked' },
-    });
-    
-    return {
-      runId,
-      status: isSync ? 'completed' : 'running',
-      output: { result: 'mocked' },
-    };
-  }
-  
-  async runWorkflow(workflow: any, options?: any): Promise<any> {
-    this.calls.push({
-      method: 'runWorkflow',
-      args: [workflow, options],
-      timestamp: Date.now(),
-    });
-    
-    const isSync = options?.sync ?? true;
-    const runId = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    
-    return {
-      runId,
-      sessionId: runId,
-      status: isSync ? 'completed' : 'running',
-      output: { result: 'mocked' },
-    };
-  }
-  
-  async pause(sessionId: string): Promise<void> {
-    this.calls.push({
-      method: 'pause',
-      args: [sessionId],
-      timestamp: Date.now(),
-    });
-    
-    this.sessionResults.set(sessionId, { status: 'paused' });
-  }
-  
-  async resume(sessionId: string, options?: { userResponse?: string; pendingNodeId?: string; agentSessionId?: string }): Promise<any> {
-    this.calls.push({
-      method: 'resume',
-      args: [sessionId, options],
-      timestamp: Date.now(),
-    });
-    
-    this.sessionResults.set(sessionId, { status: 'running' });
-    
-    return {
-      sessionId,
-      status: 'running',
-    };
-  }
-  
-  async stop(sessionId: string, reason?: string): Promise<void> {
-    this.calls.push({
-      method: 'stop',
-      args: [sessionId, reason],
-      timestamp: Date.now(),
-    });
-    
-    this.sessionResults.set(sessionId, { status: 'stopped' });
-  }
-  
-  async addNode(sessionId: string, nodeDefinition: any): Promise<void> {
-    this.calls.push({
-      method: 'addNode',
-      args: [sessionId, nodeDefinition],
-      timestamp: Date.now(),
-    });
-  }
-  
-  async removeNode(sessionId: string, nodeId: string): Promise<void> {
-    this.calls.push({
-      method: 'removeNode',
-      args: [sessionId, nodeId],
-      timestamp: Date.now(),
-    });
-  }
-  
-  // Helper for testing
-  clearCalls(): void {
-    this.calls = [];
-  }
-  
-  getLastCall(): MockEngineCall | undefined {
-    return this.calls[this.calls.length - 1];
-  }
-  
-  getCallsByMethod(method: string): MockEngineCall[] {
-    return this.calls.filter(c => c.method === method);
-  }
-}
-
-// ==================== Mock NodeRegistry ====================
-
-export class MockNodeRegistry {
-  private nodes: Map<string, any> = new Map();
-  
-  register(type: string, factory: any): void {
-    this.nodes.set(type, factory);
-  }
-  
-  get(type: string): any {
-    return this.nodes.get(type);
-  }
-  
-  has(type: string): boolean {
-    return this.nodes.has(type);
-  }
-  
-  list(): string[] {
-    return Array.from(this.nodes.keys());
-  }
-}

package/src/env/workflow/storage/sqlite.test.ts

@@ -1,179 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-
-/**
- * SQLite Storage Tests
- * 
- * Uses Bun's built-in bun:sqlite module.
- * 
- * Note: After session-based refactoring, workflow runs are managed via SessionComponent.
- * Only the workflows table tests are relevant here.
- */
-
-describe('SQLite Storage', () => {
-  // Helper to get in-memory database
-  function createTestDatabase() {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { Database } = require("bun:sqlite");
-    return new Database(":memory:");
-  }
-
-  describe('getDatabase', () => {
-    it('should return a Database instance', () => {
-      const db = createTestDatabase();
-      expect(db).toBeDefined();
-      expect(typeof db.exec).toBe('function');
-      expect(typeof db.prepare).toBe('function');
-      db.close();
-    });
-
-    it('should support basic SQL execution', () => {
-      const db = createTestDatabase();
-      db.exec("CREATE TABLE test (id TEXT PRIMARY KEY, name TEXT)");
-      
-      const stmt = db.prepare("INSERT INTO test (id, name) VALUES (?, ?)");
-      stmt.run("1", "test");
-      
-      const result = db.prepare("SELECT * FROM test").all();
-      expect(result).toHaveLength(1);
-      expect(result[0].name).toBe("test");
-      
-      db.close();
-    });
-  });
-
-  describe('initializeTables', () => {
-    it('should create workflows table', () => {
-      const db = createTestDatabase();
-      
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS workflows (
-          id TEXT PRIMARY KEY,
-          name TEXT NOT NULL UNIQUE,
-          version TEXT NOT NULL DEFAULT '1.0',
-          description TEXT,
-          definition TEXT NOT NULL,
-          config TEXT NOT NULL DEFAULT '{}',
-          metadata TEXT NOT NULL DEFAULT '{}',
-          tags TEXT NOT NULL DEFAULT '[]',
-          task_id INTEGER,
-          created_at TEXT NOT NULL,
-          updated_at TEXT NOT NULL
-        )
-      `);
-      
-      // Verify table exists
-      const tableInfo = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='workflows'").get();
-      expect(tableInfo).toBeDefined();
-      
-      db.close();
-    });
-
-    it('should create indexes', () => {
-      const db = createTestDatabase();
-      
-      // Create workflows table first
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS workflows (
-          id TEXT PRIMARY KEY,
-          name TEXT NOT NULL UNIQUE,
-          version TEXT NOT NULL DEFAULT '1.0',
-          description TEXT,
-          definition TEXT NOT NULL,
-          config TEXT NOT NULL DEFAULT '{}',
-          metadata TEXT NOT NULL DEFAULT '{}',
-          tags TEXT NOT NULL DEFAULT '[]',
-          task_id INTEGER,
-          created_at TEXT NOT NULL,
-          updated_at TEXT NOT NULL
-        )
-      `);
-      
-      // Create indexes
-      db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_workflows_name ON workflows(name);
-        CREATE INDEX IF NOT EXISTS idx_workflows_tags ON workflows(tags);
-        CREATE INDEX IF NOT EXISTS idx_workflows_task_id ON workflows(task_id);
-      `);
-      
-      // Verify indexes exist
-      const indexes = db.prepare("SELECT name FROM sqlite_master WHERE type='index'").all();
-      const indexNames = indexes.map((idx: any) => idx.name);
-      expect(indexNames).toContain("idx_workflows_name");
-      expect(indexNames).toContain("idx_workflows_tags");
-      expect(indexNames).toContain("idx_workflows_task_id");
-      
-      db.close();
-    });
-  });
-
-  describe('getDatabasePath', () => {
-    it('should return default database path', () => {
-      const { getDatabasePath } = require("./sqlite");
-      const path = getDatabasePath();
-      expect(path).toBeDefined();
-      expect(path).toContain("workflows.db");
-    });
-  });
-
-  describe('closeDatabase', () => {
-    it('should close database without error', () => {
-      const db = createTestDatabase();
-      expect(() => db.close()).not.toThrow();
-    });
-  });
-
-  describe('integration: workflow table operations', () => {
-    it('should perform CRUD operations on workflows table', () => {
-      const db = createTestDatabase();
-      
-      // Create workflows table
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS workflows (
-          id TEXT PRIMARY KEY,
-          name TEXT NOT NULL UNIQUE,
-          version TEXT NOT NULL DEFAULT '1.0',
-          description TEXT,
-          definition TEXT NOT NULL,
-          config TEXT NOT NULL DEFAULT '{}',
-          metadata TEXT NOT NULL DEFAULT '{}',
-          tags TEXT NOT NULL DEFAULT '[]',
-          task_id INTEGER,
-          created_at TEXT NOT NULL,
-          updated_at TEXT NOT NULL
-        )
-      `);
-      
-      // Insert a workflow
-      const now = new Date().toISOString();
-      const workflowDef = JSON.stringify({ name: "Test", nodes: [] });
-      
-      db.prepare(`
-        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run("wf-1", "TestWorkflow", "1.0", "A test workflow", workflowDef, "{}", "{}", "[]", now, now);
-      
-      // Verify data
-      const workflow = db.prepare("SELECT * FROM workflows WHERE id = ?").get("wf-1");
-      expect(workflow).toBeDefined();
-      expect(workflow.name).toBe("TestWorkflow");
-      expect(workflow.description).toBe("A test workflow");
-      
-      // Update workflow
-      db.prepare(`
-        UPDATE workflows SET description = ?, updated_at = ? WHERE id = ?
-      `).run("Updated description", now, "wf-1");
-      
-      const updatedWorkflow = db.prepare("SELECT * FROM workflows WHERE id = ?").get("wf-1");
-      expect(updatedWorkflow.description).toBe("Updated description");
-      
-      // Delete workflow
-      db.prepare("DELETE FROM workflows WHERE id = ?").run("wf-1");
-      
-      const deletedWorkflow = db.prepare("SELECT * FROM workflows WHERE id = ?").get("wf-1");
-      // SQLite's .get() returns null when no rows found
-      expect(deletedWorkflow).toBeNull();
-      
-      db.close();
-    });
-  });
-});