@ai-setting/roy-agent-core 1.0.0

package/src/env/workflow/storage/workflow-repo.test.ts

@@ -0,0 +1,780 @@
+import { describe, it, expect, beforeEach } from 'bun:test';
+import { randomUUID } from 'crypto';
+import type { Workflow, WorkflowDefinition } from '../types';
+
+/**
+ * WorkflowRepository Tests
+ * 
+ * Tests CRUD operations for workflows in SQLite.
+ */
+
+// Helper to create in-memory database
+function createTestDatabase() {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { Database } = require("bun:sqlite");
+  const db = new Database(":memory:");
+  
+  // Create tables
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS workflows (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      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
+    )
+  `);
+  
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_workflows_name ON workflows(name)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_workflows_tags ON workflows(tags)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_workflows_task_id ON workflows(task_id)`);
+  
+  return db;
+}
+
+interface WorkflowRow {
+  id: string;
+  name: string;
+  version: string;
+  description: string | null;
+  definition: string;
+  config: string;
+  metadata: string;
+  tags: string;
+  task_id: number | null;
+  created_at: string;
+  updated_at: string;
+}
+
+/**
+ * Row to Workflow conversion helper
+ */
+function rowToWorkflow(row: WorkflowRow): Workflow {
+  const metadata = JSON.parse(row.metadata);
+  // Merge task_id from column into metadata
+  if (row.task_id !== null) {
+    metadata.taskId = row.task_id;
+  }
+  return {
+    id: row.id,
+    name: row.name,
+    version: row.version,
+    description: row.description || undefined,
+    definition: JSON.parse(row.definition),
+    config: JSON.parse(row.config),
+    metadata,
+    tags: JSON.parse(row.tags),
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at),
+  };
+}
+
+describe('WorkflowRepository', () => {
+  let db: any;
+  
+  beforeEach(() => {
+    db = createTestDatabase();
+  });
+  
+  describe('create', () => {
+    it('should create a new workflow', () => {
+      const id = randomUUID();
+      const now = new Date().toISOString();
+      const definition: WorkflowDefinition = {
+        name: 'TestWorkflow',
+        version: '1.0',
+        description: 'A test workflow',
+        nodes: [
+          { id: 'node1', type: 'llm' }
+        ],
+      };
+      
+      const stmt = db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      
+      stmt.run(
+        id,
+        definition.name,
+        definition.version,
+        definition.description || null,
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        now,
+        now
+      );
+      
+      const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id) as WorkflowRow;
+      const workflow = rowToWorkflow(row);
+      
+      expect(workflow.id).toBe(id);
+      expect(workflow.name).toBe('TestWorkflow');
+      expect(workflow.version).toBe('1.0');
+      expect(workflow.definition.nodes).toHaveLength(1);
+    });
+    
+    it('should set timestamps correctly', () => {
+      const id = randomUUID();
+      const now = new Date().toISOString();
+      const definition: WorkflowDefinition = {
+        name: 'TestWorkflow',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        id,
+        definition.name,
+        definition.version,
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        now,
+        now
+      );
+      
+      const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id) as WorkflowRow;
+      
+      expect(row.created_at).toBe(now);
+      expect(row.updated_at).toBe(now);
+    });
+  });
+  
+  describe('getById', () => {
+    it('should retrieve a workflow by id', () => {
+      const id = randomUUID();
+      const now = new Date().toISOString();
+      const definition: WorkflowDefinition = {
+        name: 'TestWorkflow',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        id,
+        definition.name,
+        definition.version,
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        now,
+        now
+      );
+      
+      const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id) as WorkflowRow | undefined;
+      expect(row).toBeDefined();
+      
+      const workflow = rowToWorkflow(row!);
+      expect(workflow.id).toBe(id);
+      expect(workflow.name).toBe('TestWorkflow');
+    });
+    
+    it('should return undefined for non-existent id', () => {
+      const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get('non-existent') as WorkflowRow | null | undefined;
+      expect(row).toBeNull();
+    });
+  });
+  
+  describe('getByName', () => {
+    it('should retrieve a workflow by name', () => {
+      const now = new Date().toISOString();
+      const definition: WorkflowDefinition = {
+        name: 'MyWorkflow',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        randomUUID(),
+        definition.name,
+        definition.version,
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        now,
+        now
+      );
+      
+      const row = db.prepare("SELECT * FROM workflows WHERE name = ? ORDER BY updated_at DESC LIMIT 1").get('MyWorkflow') as WorkflowRow | undefined;
+      expect(row).toBeDefined();
+      
+      const workflow = rowToWorkflow(row!);
+      expect(workflow.name).toBe('MyWorkflow');
+    });
+    
+    it('should return latest version when multiple versions exist', () => {
+      const now = new Date().toISOString();
+      const definition1: WorkflowDefinition = {
+        name: 'MultiVersion',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      const definition2: WorkflowDefinition = {
+        name: 'MultiVersion',
+        version: '2.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      // Insert version 1.0
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        randomUUID(),
+        definition1.name,
+        definition1.version,
+        JSON.stringify(definition1),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        now,
+        now
+      );
+      
+      // Insert version 2.0 (updated later)
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        randomUUID(),
+        definition2.name,
+        definition2.version,
+        JSON.stringify(definition2),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        now,
+        new Date(Date.now() + 1000).toISOString() // Updated later
+      );
+      
+      const row = db.prepare("SELECT * FROM workflows WHERE name = ? ORDER BY updated_at DESC LIMIT 1").get('MultiVersion') as WorkflowRow | undefined;
+      expect(row).toBeDefined();
+      
+      const workflow = rowToWorkflow(row!);
+      expect(workflow.version).toBe('2.0');
+    });
+  });
+  
+  describe('list', () => {
+    it('should list all workflows', () => {
+      const now = new Date().toISOString();
+      
+      // Create multiple workflows
+      for (let i = 0; i < 3; i++) {
+        const definition: WorkflowDefinition = {
+          name: `Workflow${i}`,
+          version: '1.0',
+          nodes: [{ id: 'node1', type: 'llm' }],
+        };
+        
+        db.prepare(`
+          INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(
+          randomUUID(),
+          definition.name,
+          definition.version,
+          JSON.stringify(definition),
+          JSON.stringify({}),
+          JSON.stringify({}),
+          JSON.stringify([]),
+          now,
+          now
+        );
+      }
+      
+      const rows = db.prepare("SELECT * FROM workflows ORDER BY updated_at DESC").all() as WorkflowRow[];
+      expect(rows).toHaveLength(3);
+    });
+    
+    it('should support pagination', () => {
+      const now = new Date().toISOString();
+      
+      // Create 5 workflows
+      for (let i = 0; i < 5; i++) {
+        const definition: WorkflowDefinition = {
+          name: `Workflow${i}`,
+          version: '1.0',
+          nodes: [{ id: 'node1', type: 'llm' }],
+        };
+        
+        db.prepare(`
+          INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(
+          randomUUID(),
+          definition.name,
+          definition.version,
+          JSON.stringify(definition),
+          JSON.stringify({}),
+          JSON.stringify({}),
+          JSON.stringify([]),
+          now,
+          now
+        );
+      }
+      
+      const rows = db.prepare("SELECT * FROM workflows ORDER BY updated_at DESC LIMIT 2 OFFSET 1").all() as WorkflowRow[];
+      expect(rows).toHaveLength(2);
+    });
+    
+    it('should filter by tags', () => {
+      const now = new Date().toISOString();
+      
+      // Create workflow with tag
+      const definition: WorkflowDefinition = {
+        name: 'TaggedWorkflow',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        randomUUID(),
+        definition.name,
+        definition.version,
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify(['test', 'workflow']),
+        now,
+        now
+      );
+      
+      // Query using LIKE for tag search (stored as JSON array)
+      const rows = db.prepare("SELECT * FROM workflows WHERE tags LIKE ?").all('%test%') as WorkflowRow[];
+      expect(rows).toHaveLength(1);
+      expect(rowToWorkflow(rows[0]).tags).toContain('test');
+    });
+  });
+  
+  describe('update', () => {
+    it('should update a workflow', () => {
+      const id = randomUUID();
+      const now = new Date().toISOString();
+      const definition: WorkflowDefinition = {
+        name: 'Original',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        id,
+        definition.name,
+        definition.version,
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        now,
+        now
+      );
+      
+      // Update the workflow
+      const updatedNow = new Date().toISOString();
+      const updatedDefinition: WorkflowDefinition = {
+        ...definition,
+        name: 'Updated',
+      };
+      
+      db.prepare(`
+        UPDATE workflows 
+        SET name = ?, definition = ?, updated_at = ?
+        WHERE id = ?
+      `).run(
+        updatedDefinition.name,
+        JSON.stringify(updatedDefinition),
+        updatedNow,
+        id
+      );
+      
+      const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id) as WorkflowRow;
+      const workflow = rowToWorkflow(row);
+      
+      expect(workflow.name).toBe('Updated');
+      expect(workflow.updatedAt).toEqual(new Date(updatedNow));
+    });
+    
+    it('should update only specific fields', () => {
+      const id = randomUUID();
+      const now = new Date().toISOString();
+      const definition: WorkflowDefinition = {
+        name: 'TestWorkflow',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        id,
+        definition.name,
+        definition.version,
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        now,
+        now
+      );
+      
+      // Update only tags
+      db.prepare(`
+        UPDATE workflows 
+        SET tags = ?, updated_at = ?
+        WHERE id = ?
+      `).run(
+        JSON.stringify(['new-tag']),
+        new Date().toISOString(),
+        id
+      );
+      
+      const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id) as WorkflowRow;
+      const workflow = rowToWorkflow(row);
+      
+      expect(workflow.name).toBe('TestWorkflow'); // Unchanged
+      expect(workflow.tags).toContain('new-tag');
+    });
+  });
+  
+  describe('delete', () => {
+    it('should delete a workflow', () => {
+      const id = randomUUID();
+      const now = new Date().toISOString();
+      const definition: WorkflowDefinition = {
+        name: 'ToDelete',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        id,
+        definition.name,
+        definition.version,
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        now,
+        now
+      );
+      
+      // Delete the workflow
+      db.prepare("DELETE FROM workflows WHERE id = ?").run(id);
+      
+      const row = db.prepare("SELECT * FROM workflows WHERE id = ?").get(id);
+      expect(row).toBeNull();
+    });
+    
+    it('should not affect other workflows when deleting one', () => {
+      const now = new Date().toISOString();
+      const definition: WorkflowDefinition = {
+        name: 'Test',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      const id1 = randomUUID();
+      const id2 = randomUUID();
+      
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id1, definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+      
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id2, definition.name, definition.version, JSON.stringify(definition), JSON.stringify({}), JSON.stringify({}), JSON.stringify([]), now, now);
+      
+      // Delete one
+      db.prepare("DELETE FROM workflows WHERE id = ?").run(id1);
+      
+      const rows = db.prepare("SELECT * FROM workflows").all();
+      expect(rows).toHaveLength(1);
+      expect((rows[0] as WorkflowRow).id).toBe(id2);
+    });
+  });
+  
+  describe('exists', () => {
+    it('should return true for existing workflow', () => {
+      const id = randomUUID();
+      const now = new Date().toISOString();
+      const definition: WorkflowDefinition = {
+        name: 'Exists',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        id,
+        definition.name,
+        definition.version,
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        now,
+        now
+      );
+      
+      const count = db.prepare("SELECT COUNT(*) as count FROM workflows WHERE id = ?").get(id) as { count: number };
+      expect(count.count).toBeGreaterThan(0);
+    });
+    
+    it('should return false for non-existing workflow', () => {
+      const count = db.prepare("SELECT COUNT(*) as count FROM workflows WHERE id = ?").get('non-existent') as { count: number };
+      expect(count.count).toBe(0);
+    });
+  });
+  
+  describe('list() with taskId filter', () => {
+    it('should filter workflows by taskId', () => {
+      const now = new Date().toISOString();
+      
+      // Create workflows with different taskIds
+      const definition: WorkflowDefinition = {
+        name: 'Workflow1',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      // Insert with task_id = 1
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, task_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        randomUUID(),
+        definition.name,
+        definition.version,
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        1,
+        now,
+        now
+      );
+      
+      // Insert with task_id = 2
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, task_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        randomUUID(),
+        'Workflow2',
+        definition.version,
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        2,
+        now,
+        now
+      );
+      
+      // Query with task_id = 1
+      const rows = db.prepare("SELECT * FROM workflows WHERE task_id = ?").all(1) as WorkflowRow[];
+      expect(rows).toHaveLength(1);
+      expect(rows[0].name).toBe('Workflow1');
+    });
+  });
+  
+  describe('list() with search', () => {
+    it('should search in description', () => {
+      const now = new Date().toISOString();
+      const definition: WorkflowDefinition = {
+        name: 'Workflow1',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      // Create workflow with CI description
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        randomUUID(),
+        definition.name,
+        definition.version,
+        'CI pipeline workflow',
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        now,
+        now
+      );
+      
+      // Create workflow with Data description
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        randomUUID(),
+        'Workflow2',
+        definition.version,
+        'Data processing workflow',
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify([]),
+        now,
+        now
+      );
+      
+      // Search in-memory for CI
+      const allRows = db.prepare("SELECT * FROM workflows").all() as WorkflowRow[];
+      const workflows = allRows.map(rowToWorkflow);
+      const ciWorkflows = workflows.filter(w => w.description?.toLowerCase().includes('ci'));
+      
+      expect(ciWorkflows).toHaveLength(1);
+      expect(ciWorkflows[0].description).toContain('CI');
+    });
+    
+    it('should search in tags', () => {
+      const now = new Date().toISOString();
+      const definition: WorkflowDefinition = {
+        name: 'TaggedWorkflow',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, definition, config, metadata, tags, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        randomUUID(),
+        definition.name,
+        definition.version,
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify(['ci', 'deploy']),
+        now,
+        now
+      );
+      
+      // Search in-memory for 'ci' tag
+      const allRows = db.prepare("SELECT * FROM workflows").all() as WorkflowRow[];
+      const workflows = allRows.map(rowToWorkflow);
+      const ciWorkflows = workflows.filter(w => w.tags.some(tag => tag.toLowerCase().includes('ci')));
+      
+      expect(ciWorkflows).toHaveLength(1);
+      expect(ciWorkflows[0].tags).toContain('ci');
+    });
+  });
+  
+  describe('list() with combined filters', () => {
+    it('should combine taskId + tag + search', () => {
+      const now = new Date().toISOString();
+      const definition: WorkflowDefinition = {
+        name: 'Workflow1',
+        version: '1.0',
+        nodes: [{ id: 'node1', type: 'llm' }],
+      };
+      
+      // Create workflow 1: taskId=1, tag=ci, description=Build
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, task_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        randomUUID(),
+        definition.name,
+        definition.version,
+        'Build workflow',
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify(['ci']),
+        1,
+        now,
+        now
+      );
+      
+      // Create workflow 2: taskId=1, tag=ci, description=Deploy
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, task_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        randomUUID(),
+        'Workflow2',
+        definition.version,
+        'Deploy workflow',
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify(['ci']),
+        1,
+        now,
+        now
+      );
+      
+      // Create workflow 3: taskId=2, tag=ci, description=Test
+      db.prepare(`
+        INSERT INTO workflows (id, name, version, description, definition, config, metadata, tags, task_id, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        randomUUID(),
+        'Workflow3',
+        definition.version,
+        'Test workflow',
+        JSON.stringify(definition),
+        JSON.stringify({}),
+        JSON.stringify({}),
+        JSON.stringify(['ci']),
+        2,
+        now,
+        now
+      );
+      
+      // Query: taskId=1 AND tag=ci AND search=build
+      let rows = db.prepare("SELECT * FROM workflows WHERE task_id = ?").all(1) as WorkflowRow[];
+      let workflows = rows.map(rowToWorkflow);
+      
+      // Filter by tag
+      workflows = workflows.filter(w => w.tags.includes('ci'));
+      
+      // Filter by search
+      workflows = workflows.filter(w => w.description?.toLowerCase().includes('build'));
+      
+      expect(workflows).toHaveLength(1);
+      expect(workflows[0].metadata.taskId).toBe(1);
+      expect(workflows[0].tags).toContain('ci');
+      expect(workflows[0].description).toContain('Build');
+    });
+  });
+});