@assistkick/create 1.7.0 → 1.9.0

package/templates/assistkick-product-system/packages/backend/src/services/workflow_service.test.ts

@@ -0,0 +1,275 @@
+import { describe, it, mock, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { WorkflowService } from './workflow_service.ts';
+
+const MOCK_WORKFLOW = {
+  id: 'wf-1',
+  name: 'Test Workflow',
+  description: 'A test workflow',
+  projectId: null,
+  featureType: null,
+  isDefault: 0,
+  graphData: '{"nodes":[],"edges":[]}',
+  createdAt: '2024-01-01T00:00:00Z',
+  updatedAt: '2024-01-01T00:00:00Z',
+};
+
+const MOCK_DEFAULT_WORKFLOW = {
+  id: 'wf-default',
+  name: 'Default Pipeline',
+  description: 'Default workflow',
+  projectId: null,
+  featureType: null,
+  isDefault: 1,
+  graphData: '{"nodes":[{"id":"start_1"}],"edges":[]}',
+  createdAt: '2024-01-01T00:00:00Z',
+  updatedAt: '2024-01-01T00:00:00Z',
+};
+
+const createMockDb = () => {
+  let selectResults: any[][] = [];
+  let selectCallIndex = 0;
+
+  const db = {
+    select: mock.fn(() => {
+      const selectObj = {
+        from: mock.fn(() => {
+          const fromObj = {
+            where: mock.fn(() => {
+              const result = selectResults[selectCallIndex] || [];
+              selectCallIndex++;
+              return result;
+            }),
+          };
+          return fromObj;
+        }),
+      };
+      return selectObj;
+    }),
+    insert: mock.fn(() => ({
+      values: mock.fn(() => Promise.resolve()),
+    })),
+    update: mock.fn(() => ({
+      set: mock.fn(() => ({
+        where: mock.fn(() => Promise.resolve()),
+      })),
+    })),
+    delete: mock.fn(() => ({
+      where: mock.fn(() => Promise.resolve()),
+    })),
+    _setSelectResults: (results: any[][]) => {
+      selectResults = results;
+      selectCallIndex = 0;
+    },
+  };
+
+  return db;
+};
+
+const createService = (db: any) => {
+  return new WorkflowService({
+    getDb: () => db,
+    log: mock.fn(),
+  });
+};
+
+describe('WorkflowService', () => {
+  let db: ReturnType<typeof createMockDb>;
+  let service: WorkflowService;
+
+  beforeEach(() => {
+    db = createMockDb();
+    service = createService(db);
+  });
+
+  describe('list', () => {
+    it('returns global workflows when no projectId', async () => {
+      db._setSelectResults([[MOCK_DEFAULT_WORKFLOW]]);
+
+      const result = await service.list();
+
+      assert.equal(result.length, 1);
+      assert.equal(db.select.mock.calls.length, 1);
+    });
+
+    it('returns global + project workflows when projectId provided', async () => {
+      const projectWorkflow = { ...MOCK_WORKFLOW, projectId: 'proj_001' };
+      db._setSelectResults([[MOCK_DEFAULT_WORKFLOW, projectWorkflow]]);
+
+      const result = await service.list('proj_001');
+
+      assert.equal(result.length, 2);
+    });
+  });
+
+  describe('getById', () => {
+    it('returns workflow when found', async () => {
+      db._setSelectResults([[MOCK_WORKFLOW]]);
+
+      const result = await service.getById('wf-1');
+
+      assert.ok(result);
+      assert.equal(result.name, 'Test Workflow');
+      assert.equal(result.graphData, '{"nodes":[],"edges":[]}');
+    });
+
+    it('returns null when not found', async () => {
+      db._setSelectResults([[]]);
+
+      const result = await service.getById('nonexistent');
+
+      assert.equal(result, null);
+    });
+  });
+
+  describe('create', () => {
+    it('creates a workflow with correct fields', async () => {
+      const result = await service.create({
+        name: 'New Workflow',
+        graphData: '{"nodes":[],"edges":[]}',
+      });
+
+      assert.ok(result.id);
+      assert.equal(result.name, 'New Workflow');
+      assert.equal(result.projectId, null);
+      assert.equal(result.isDefault, 0);
+      assert.equal(result.graphData, '{"nodes":[],"edges":[]}');
+      assert.ok(result.createdAt);
+      assert.equal(db.insert.mock.calls.length, 1);
+    });
+
+    it('creates a project-scoped workflow', async () => {
+      const result = await service.create({
+        name: 'Project Workflow',
+        graphData: '{"nodes":[],"edges":[]}',
+        projectId: 'proj_001',
+      });
+
+      assert.equal(result.projectId, 'proj_001');
+    });
+
+    it('sets description when provided', async () => {
+      const result = await service.create({
+        name: 'Described Workflow',
+        description: 'With description',
+        graphData: '{"nodes":[],"edges":[]}',
+      });
+
+      assert.equal(result.description, 'With description');
+    });
+
+    it('creates a workflow with featureType', async () => {
+      const result = await service.create({
+        name: 'Video Workflow',
+        graphData: '{"nodes":[],"edges":[]}',
+        featureType: 'video',
+      });
+
+      assert.equal(result.featureType, 'video');
+    });
+
+    it('defaults featureType to null when not provided', async () => {
+      const result = await service.create({
+        name: 'Generic Workflow',
+        graphData: '{"nodes":[],"edges":[]}',
+      });
+
+      assert.equal(result.featureType, null);
+    });
+  });
+
+  describe('update', () => {
+    it('updates workflow name', async () => {
+      db._setSelectResults([[MOCK_WORKFLOW]]);
+
+      const result = await service.update('wf-1', { name: 'Updated Name' });
+
+      assert.equal(result.name, 'Updated Name');
+      assert.equal(db.update.mock.calls.length, 1);
+    });
+
+    it('updates workflow graphData', async () => {
+      db._setSelectResults([[MOCK_WORKFLOW]]);
+
+      const result = await service.update('wf-1', { graphData: '{"nodes":[{"id":"new"}],"edges":[]}' });
+
+      assert.equal(result.graphData, '{"nodes":[{"id":"new"}],"edges":[]}');
+    });
+
+    it('updates workflow description', async () => {
+      db._setSelectResults([[MOCK_WORKFLOW]]);
+
+      const result = await service.update('wf-1', { description: 'New description' });
+
+      assert.equal(result.description, 'New description');
+    });
+
+    it('updates workflow featureType', async () => {
+      db._setSelectResults([[MOCK_WORKFLOW]]);
+
+      const result = await service.update('wf-1', { featureType: 'video' });
+
+      assert.equal(result.featureType, 'video');
+    });
+
+    it('throws when workflow not found', async () => {
+      db._setSelectResults([[]]);
+
+      await assert.rejects(
+        () => service.update('nonexistent', { name: 'X' }),
+        { message: 'Workflow not found' },
+      );
+    });
+  });
+
+  describe('delete', () => {
+    it('deletes a workflow with no active executions', async () => {
+      // First: getById, second: check active executions
+      db._setSelectResults([[MOCK_WORKFLOW], []]);
+
+      await service.delete('wf-1');
+
+      assert.equal(db.delete.mock.calls.length, 1);
+    });
+
+    it('throws when workflow not found', async () => {
+      db._setSelectResults([[]]);
+
+      await assert.rejects(
+        () => service.delete('nonexistent'),
+        { message: 'Workflow not found' },
+      );
+    });
+
+    it('throws when workflow has active executions', async () => {
+      const activeExecution = { id: 'exec-1', workflowId: 'wf-1', status: 'running' };
+      db._setSelectResults([[MOCK_WORKFLOW], [activeExecution]]);
+
+      await assert.rejects(
+        () => service.delete('wf-1'),
+        { message: 'Cannot delete a workflow with active executions' },
+      );
+    });
+  });
+
+  describe('setDefault', () => {
+    it('sets a workflow as default', async () => {
+      db._setSelectResults([[MOCK_WORKFLOW]]);
+
+      const result = await service.setDefault('wf-1');
+
+      assert.equal(result.isDefault, 1);
+      // Two update calls: one to unset previous default, one to set new
+      assert.equal(db.update.mock.calls.length, 2);
+    });
+
+    it('throws when workflow not found', async () => {
+      db._setSelectResults([[]]);
+
+      await assert.rejects(
+        () => service.setDefault('nonexistent'),
+        { message: 'Workflow not found' },
+      );
+    });
+  });
+});

package/templates/assistkick-product-system/packages/backend/src/services/workflow_service.ts

@@ -0,0 +1,245 @@
+/**
+ * Workflow service — CRUD operations for workflows.
+ * Handles listing, creating, updating, deleting workflows,
+ * and managing the is_default flag with scope-level uniqueness.
+ */
+
+import { eq, and, isNull, or } from 'drizzle-orm';
+import { workflows, workflowExecutions } from '@assistkick/shared/db/schema.js';
+import { randomUUID } from 'node:crypto';
+
+interface WorkflowServiceDeps {
+  getDb: () => any;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+export interface WorkflowRecord {
+  id: string;
+  name: string;
+  description: string | null;
+  projectId: string | null;
+  featureType: string | null;
+  triggerColumn: string | null;
+  isDefault: number;
+  graphData: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface WorkflowListItem {
+  id: string;
+  name: string;
+  description: string | null;
+  projectId: string | null;
+  featureType: string | null;
+  triggerColumn: string | null;
+  isDefault: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export class WorkflowService {
+  private readonly getDb: () => any;
+  private readonly log: (tag: string, ...args: any[]) => void;
+
+  constructor({ getDb, log }: WorkflowServiceDeps) {
+    this.getDb = getDb;
+    this.log = log;
+  }
+
+  /** List workflows visible to the given scope (global + project-specific). Excludes graph_data.
+   *  Optional filters: featureType and triggerColumn for column-gated video workflow selection. */
+  list = async (projectId?: string, featureType?: string, triggerColumn?: string): Promise<WorkflowListItem[]> => {
+    const db = this.getDb();
+
+    const conditions = [];
+
+    // Scope: global + project-specific
+    if (projectId) {
+      conditions.push(or(isNull(workflows.projectId), eq(workflows.projectId, projectId)));
+    } else {
+      conditions.push(isNull(workflows.projectId));
+    }
+
+    // Optional featureType filter
+    if (featureType) {
+      conditions.push(eq(workflows.featureType, featureType));
+    }
+
+    // Optional triggerColumn filter
+    if (triggerColumn) {
+      conditions.push(eq(workflows.triggerColumn, triggerColumn));
+    }
+
+    const rows = await db
+      .select({
+        id: workflows.id,
+        name: workflows.name,
+        description: workflows.description,
+        projectId: workflows.projectId,
+        featureType: workflows.featureType,
+        triggerColumn: workflows.triggerColumn,
+        isDefault: workflows.isDefault,
+        createdAt: workflows.createdAt,
+        updatedAt: workflows.updatedAt,
+      })
+      .from(workflows)
+      .where(and(...conditions));
+
+    this.log('WORKFLOWS', `Listed ${rows.length} workflows`);
+    return rows;
+  };
+
+  /** Get a single workflow by ID, including graph_data. */
+  getById = async (id: string): Promise<WorkflowRecord | null> => {
+    const db = this.getDb();
+    const [row] = await db.select().from(workflows).where(eq(workflows.id, id));
+    return row || null;
+  };
+
+  /** Create a new workflow. */
+  create = async (data: {
+    name: string;
+    description?: string | null;
+    projectId?: string | null;
+    featureType?: string | null;
+    triggerColumn?: string | null;
+    graphData: string;
+  }): Promise<WorkflowRecord> => {
+    const db = this.getDb();
+    const now = new Date().toISOString();
+    const id = randomUUID();
+
+    const record: WorkflowRecord = {
+      id,
+      name: data.name,
+      description: data.description || null,
+      projectId: data.projectId || null,
+      featureType: data.featureType || null,
+      triggerColumn: data.triggerColumn || null,
+      isDefault: 0,
+      graphData: data.graphData,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    await db.insert(workflows).values(record);
+    this.log('WORKFLOWS', `Created workflow: ${data.name} (${id})`);
+    return record;
+  };
+
+  /** Update a workflow's name, description, featureType, triggerColumn, and/or graph_data. */
+  update = async (id: string, data: {
+    name?: string;
+    description?: string;
+    featureType?: string | null;
+    triggerColumn?: string | null;
+    graphData?: string;
+  }): Promise<WorkflowRecord> => {
+    const db = this.getDb();
+    const existing = await this.getById(id);
+
+    if (!existing) {
+      throw new Error('Workflow not found');
+    }
+
+    const now = new Date().toISOString();
+    const updates: Record<string, any> = { updatedAt: now };
+
+    if (data.name !== undefined) updates.name = data.name;
+    if (data.description !== undefined) updates.description = data.description;
+    if (data.featureType !== undefined) updates.featureType = data.featureType;
+    if (data.triggerColumn !== undefined) updates.triggerColumn = data.triggerColumn;
+    if (data.graphData !== undefined) updates.graphData = data.graphData;
+
+    await db.update(workflows).set(updates).where(eq(workflows.id, id));
+
+    this.log('WORKFLOWS', `Updated workflow: ${existing.name} (${id})`);
+    return { ...existing, ...updates };
+  };
+
+  /** Delete a workflow. Blocked if it has active (running/pending) executions. */
+  delete = async (id: string): Promise<void> => {
+    const db = this.getDb();
+    const existing = await this.getById(id);
+
+    if (!existing) {
+      throw new Error('Workflow not found');
+    }
+
+    // Check for active executions
+    const activeExecutions = await db
+      .select()
+      .from(workflowExecutions)
+      .where(
+        and(
+          eq(workflowExecutions.workflowId, id),
+          or(
+            eq(workflowExecutions.status, 'running'),
+            eq(workflowExecutions.status, 'pending'),
+          ),
+        ),
+      );
+
+    if (activeExecutions.length > 0) {
+      throw new Error('Cannot delete a workflow with active executions');
+    }
+
+    await db.delete(workflows).where(eq(workflows.id, id));
+    this.log('WORKFLOWS', `Deleted workflow: ${existing.name} (${id})`);
+  };
+
+  /**
+   * Resolve the default workflow for a given project scope.
+   * Priority: project-specific default → global default.
+   * Returns null if no default workflow exists.
+   */
+  resolveDefault = async (projectId?: string): Promise<WorkflowRecord | null> => {
+    const db = this.getDb();
+
+    // Try project-specific default first
+    if (projectId) {
+      const [projectDefault] = await db.select().from(workflows).where(
+        and(eq(workflows.projectId, projectId), eq(workflows.isDefault, 1)),
+      );
+      if (projectDefault) return projectDefault;
+    }
+
+    // Fall back to global default
+    const [globalDefault] = await db.select().from(workflows).where(
+      and(isNull(workflows.projectId), eq(workflows.isDefault, 1)),
+    );
+    return globalDefault || null;
+  };
+
+  /** Set a workflow as the default for its scope, unsetting any previous default in the same scope. */
+  setDefault = async (id: string): Promise<WorkflowRecord> => {
+    const db = this.getDb();
+    const existing = await this.getById(id);
+
+    if (!existing) {
+      throw new Error('Workflow not found');
+    }
+
+    const now = new Date().toISOString();
+
+    // Unset previous default in the same scope (same project_id or both null)
+    const scopeCondition = existing.projectId
+      ? eq(workflows.projectId, existing.projectId)
+      : isNull(workflows.projectId);
+
+    await db
+      .update(workflows)
+      .set({ isDefault: 0, updatedAt: now })
+      .where(and(scopeCondition, eq(workflows.isDefault, 1)));
+
+    // Set this workflow as default
+    await db
+      .update(workflows)
+      .set({ isDefault: 1, updatedAt: now })
+      .where(eq(workflows.id, id));
+
+    this.log('WORKFLOWS', `Set default workflow: ${existing.name} (${id})`);
+    return { ...existing, isDefault: 1, updatedAt: now };
+  };
+}