@ai-setting/roy-agent-core 1.0.0

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

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

@@ -0,0 +1,179 @@
+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();
+    });
+  });
+});