0.0.15

- Implemented proper parsing for conditions like '$.trigger.doc.content == "value"'
- Added support for comparison operators: ==, !=, >, <, >=, <=
- Fixed JSONPath condition evaluation that was treating entire expressions as JSONPath queries
- Added support for string literals, numbers, booleans in condition values
- Conditions now correctly resolve JSONPath expressions and perform comparisons

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

dev/app/test-trigger/route.ts

@@ -0,0 +1,122 @@
+import { NextResponse } from 'next/server'
+import { getPayload } from 'payload'
+import config from '../../payload.config'
+
+export async function GET() {
+  console.log('Starting workflow trigger test...')
+  
+  // Get payload instance
+  const payload = await getPayload({ config })
+  
+  try {
+    // Create a test user
+    const user = await payload.create({
+      collection: 'users',
+      data: {
+        email: `test-${Date.now()}@example.com`,
+        password: 'password123'
+      }
+    })
+    
+    console.log('Created test user:', user.id)
+    
+    // Create a workflow with collection trigger
+    const workflow = await payload.create({
+      collection: 'workflows',
+      data: {
+        name: 'Test Post Creation Workflow',
+        description: 'Triggers when a post is created',
+        triggers: [
+          {
+            type: 'collection-trigger',
+            collectionSlug: 'posts',
+            operation: 'create'
+          }
+        ],
+        steps: [
+          {
+            name: 'log-post',
+            taskSlug: 'http-request-step',
+            input: JSON.stringify({
+              url: 'https://httpbin.org/post',
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json'
+              },
+              body: {
+                message: 'Post created',
+                postId: '$.trigger.doc.id',
+                postTitle: '$.trigger.doc.title'
+              }
+            })
+          }
+        ]
+      },
+      user: user.id
+    })
+    
+    console.log('Created workflow:', workflow.id, workflow.name)
+    console.log('Workflow triggers:', JSON.stringify(workflow.triggers, null, 2))
+    
+    // Create a post to trigger the workflow
+    console.log('Creating post to trigger workflow...')
+    const post = await payload.create({
+      collection: 'posts',
+      data: {
+        title: 'Test Post',
+        content: 'This should trigger the workflow',
+        _status: 'published'
+      },
+      user: user.id
+    })
+    
+    console.log('Created post:', post.id)
+    
+    // Wait a bit for workflow to execute
+    await new Promise(resolve => setTimeout(resolve, 3000))
+    
+    // Check for workflow runs
+    const runs = await payload.find({
+      collection: 'workflow-runs',
+      where: {
+        workflow: {
+          equals: workflow.id
+        }
+      }
+    })
+    
+    console.log('Workflow runs found:', runs.totalDocs)
+    
+    const result = {
+      success: runs.totalDocs > 0,
+      workflowId: workflow.id,
+      postId: post.id,
+      runsFound: runs.totalDocs,
+      runs: runs.docs.map(r => ({
+        id: r.id,
+        status: r.status,
+        triggeredBy: r.triggeredBy,
+        startedAt: r.startedAt,
+        completedAt: r.completedAt,
+        error: r.error
+      }))
+    }
+    
+    if (runs.totalDocs > 0) {
+      console.log('✅ SUCCESS: Workflow was triggered!')
+      console.log('Run status:', runs.docs[0].status)
+      console.log('Run context:', JSON.stringify(runs.docs[0].context, null, 2))
+    } else {
+      console.log('❌ FAILURE: Workflow was not triggered')
+    }
+    
+    return NextResponse.json(result)
+    
+  } catch (error) {
+    console.error('Test failed:', error)
+    return NextResponse.json({ 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Unknown error' 
+    }, { status: 500 })
+  }
+}

dev/payload-types.ts

@@ -217,7 +217,7 @@ export interface Workflow {
         /**
          * Collection that triggers the workflow
          */
-        collection?: 'posts' | null;
+        collectionSlug?: 'posts' | null;
         /**
          * Collection operation that triggers the workflow
          */
@@ -242,6 +242,10 @@ export interface Workflow {
          * Timezone for cron execution (e.g., "America/New_York", "Europe/London"). Defaults to UTC.
          */
         timezone?: string | null;
+        /**
+         * JSONPath expression that must evaluate to true for this trigger to execute the workflow (e.g., "$.doc.status == 'published'")
+         */
+        condition?: string | null;
         id?: string | null;
       }[]
     | null;
@@ -262,6 +266,10 @@ export interface Workflow {
          * Step names that must complete before this step can run
          */
         dependencies?: string[] | null;
+        /**
+         * JSONPath expression that must evaluate to true for this step to execute (e.g., "$.trigger.doc.status == 'published'")
+         */
+        condition?: string | null;
         id?: string | null;
       }[]
     | null;
@@ -584,13 +592,14 @@ export interface WorkflowsSelect<T extends boolean = true> {
     | T
     | {
         type?: T;
-        collection?: T;
+        collectionSlug?: T;
         operation?: T;
         webhookPath?: T;
         global?: T;
         globalOperation?: T;
         cronExpression?: T;
         timezone?: T;
+        condition?: T;
         id?: T;
       };
   steps?:
@@ -600,6 +609,7 @@ export interface WorkflowsSelect<T extends boolean = true> {
         name?: T;
         input?: T;
         dependencies?: T;
+        condition?: T;
         id?: T;
       };
   updatedAt?: T;
@@ -741,7 +751,7 @@ export interface TaskCreateDocument {
     /**
      * The collection slug to create a document in
      */
-    collection: string;
+    collectionSlug: string;
     /**
      * The document data to create
      */

dev/payload.config.ts

@@ -103,7 +103,8 @@ const buildConfigWithMemoryDB = async () => {
     plugins: [
       workflowsPlugin<CollectionSlug>({
         collectionTriggers: {
-          posts: true
+          posts: true,
+          media: true
         },
         steps: [
           HttpRequestStepTask,

dev/simple-trigger.spec.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import type { Payload } from 'payload'
+import { getPayload } from 'payload'
+import config from './payload.config'
+
+describe('Workflow Trigger Test', () => {
+  let payload: Payload
+
+  beforeAll(async () => {
+    payload = await getPayload({ config: await config })
+  }, 60000)
+
+  afterAll(async () => {
+    if (!payload) return
+    
+    try {
+      // Clear test data
+      const workflows = await payload.find({
+        collection: 'workflows',
+        limit: 100
+      })
+      
+      for (const workflow of workflows.docs) {
+        await payload.delete({
+          collection: 'workflows',
+          id: workflow.id
+        })
+      }
+
+      const runs = await payload.find({
+        collection: 'workflow-runs',
+        limit: 100
+      })
+      
+      for (const run of runs.docs) {
+        await payload.delete({
+          collection: 'workflow-runs',
+          id: run.id
+        })
+      }
+
+      const posts = await payload.find({
+        collection: 'posts',
+        limit: 100
+      })
+      
+      for (const post of posts.docs) {
+        await payload.delete({
+          collection: 'posts',
+          id: post.id
+        })
+      }
+    } catch (error) {
+      console.warn('Cleanup failed:', error)
+    }
+  }, 30000)
+
+  it('should create a workflow run when a post is created', async () => {
+    // Create a workflow with collection trigger
+    const workflow = await payload.create({
+      collection: 'workflows',
+      data: {
+        name: 'Test Post Creation Workflow',
+        description: 'Triggers when a post is created',
+        triggers: [
+          {
+            type: 'collection-trigger',
+            collectionSlug: 'posts',
+            operation: 'create'
+          }
+        ],
+        steps: [
+          {
+            name: 'log-post',
+            step: 'http-request-step',
+            input: {
+              url: 'https://httpbin.org/post',
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json'
+              },
+              body: {
+                message: 'Post created',
+                postId: '$.trigger.doc.id',
+                postTitle: '$.trigger.doc.content'
+              }
+            }
+          }
+        ]
+      }
+    })
+
+    expect(workflow).toBeDefined()
+    expect(workflow.id).toBeDefined()
+
+    // Create a post to trigger the workflow
+    const post = await payload.create({
+      collection: 'posts',
+      data: {
+        content: 'This should trigger the workflow'
+      }
+    })
+
+    expect(post).toBeDefined()
+    expect(post.id).toBeDefined()
+
+    // Wait a bit for workflow to execute
+    await new Promise(resolve => setTimeout(resolve, 3000))
+
+    // Check for workflow runs
+    const runs = await payload.find({
+      collection: 'workflow-runs',
+      where: {
+        workflow: {
+          equals: workflow.id
+        }
+      },
+      limit: 10
+    })
+
+    expect(runs.totalDocs).toBeGreaterThan(0)
+    expect(runs.docs[0].workflow).toBe(typeof workflow.id === 'object' ? workflow.id.toString() : workflow.id)
+    
+    console.log('✅ Workflow run created successfully!')
+    console.log(`Run status: ${runs.docs[0].status}`)
+    console.log(`Run ID: ${runs.docs[0].id}`)
+    
+    if (runs.docs[0].status === 'failed' && runs.docs[0].error) {
+      console.log(`Error: ${runs.docs[0].error}`)
+    }
+  }, 30000)
+})

dev/test-trigger.ts

@@ -0,0 +1,104 @@
+import type { Payload } from 'payload'
+import { getPayload } from 'payload'
+import config from './payload.config'
+
+async function testWorkflowTrigger() {
+  console.log('Starting workflow trigger test...')
+  
+  // Get payload instance
+  const payload = await getPayload({ config })
+  
+  try {
+    // Create a test user
+    const user = await payload.create({
+      collection: 'users',
+      data: {
+        email: 'test@example.com',
+        password: 'password123'
+      }
+    })
+    
+    console.log('Created test user:', user.id)
+    
+    // Create a workflow with collection trigger
+    const workflow = await payload.create({
+      collection: 'workflows',
+      data: {
+        name: 'Test Post Creation Workflow',
+        description: 'Triggers when a post is created',
+        triggers: [
+          {
+            type: 'collection-trigger',
+            collectionSlug: 'posts',
+            operation: 'create'
+          }
+        ],
+        steps: [
+          {
+            name: 'log-post',
+            step: 'http-request-step',
+            input: {
+              url: 'https://httpbin.org/post',
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json'
+              },
+              body: {
+                message: 'Post created',
+                postId: '$.trigger.doc.id',
+                postTitle: '$.trigger.doc.title'
+              }
+            }
+          }
+        ]
+      },
+      user: user.id
+    })
+    
+    console.log('Created workflow:', workflow.id)
+    
+    // Create a post to trigger the workflow
+    console.log('Creating post to trigger workflow...')
+    const post = await payload.create({
+      collection: 'posts',
+      data: {
+        title: 'Test Post',
+        content: 'This should trigger the workflow',
+        _status: 'published'
+      },
+      user: user.id
+    })
+    
+    console.log('Created post:', post.id)
+    
+    // Wait a bit for workflow to execute
+    await new Promise(resolve => setTimeout(resolve, 2000))
+    
+    // Check for workflow runs
+    const runs = await payload.find({
+      collection: 'workflow-runs',
+      where: {
+        workflow: {
+          equals: workflow.id
+        }
+      }
+    })
+    
+    console.log('Workflow runs found:', runs.totalDocs)
+    
+    if (runs.totalDocs > 0) {
+      console.log('✅ SUCCESS: Workflow was triggered!')
+      console.log('Run status:', runs.docs[0].status)
+      console.log('Run context:', JSON.stringify(runs.docs[0].context, null, 2))
+    } else {
+      console.log('❌ FAILURE: Workflow was not triggered')
+    }
+    
+  } catch (error) {
+    console.error('Test failed:', error)
+  } finally {
+    await payload.shutdown()
+  }
+}
+
+testWorkflowTrigger().catch(console.error)

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@xtr-dev/payload-workflows",
-  "version": "0.0.11",
+  "version": "0.0.15",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@xtr-dev/payload-workflows",
-      "version": "0.0.11",
+      "version": "0.0.15",
       "license": "MIT",
       "dependencies": {
         "jsonpath-plus": "^10.3.0",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/payload-automation",
-  "version": "0.0.11",
+  "version": "0.0.15",
   "description": "PayloadCMS Automation Plugin - Comprehensive workflow automation system with visual workflow building, execution tracking, and step types",
   "license": "MIT",
   "type": "module",
@@ -85,6 +85,7 @@
     "react-dom": "19.1.0",
     "rimraf": "3.0.2",
     "sharp": "0.34.3",
+    "tsx": "^4.20.5",
     "typescript": "5.7.3",
     "vitest": "^3.1.2"
   },

pnpm-lock.yaml

@@ -90,6 +90,9 @@ importers:
       sharp:
         specifier: 0.34.3
         version: 0.34.3
+      tsx:
+        specifier: ^4.20.5
+        version: 4.20.5
       typescript:
         specifier: 5.7.3
         version: 5.7.3
@@ -9617,7 +9620,6 @@ snapshots:
       get-tsconfig: 4.10.1
     optionalDependencies:
       fsevents: 2.3.3
-    optional: true
 
   type-check@0.4.0:
     dependencies:

src/core/trigger-custom-workflow.ts

@@ -1,7 +1,7 @@
 import type { Payload, PayloadRequest } from 'payload'
 
 import { initializeLogger } from '../plugin/logger.js'
-import { type Workflow, WorkflowExecutor } from './workflow-executor.js'
+import { type PayloadWorkflow, WorkflowExecutor } from './workflow-executor.js'
 
 export interface CustomTriggerOptions {
   /**
@@ -142,7 +142,7 @@ export async function triggerCustomWorkflow(
         }
 
         // Execute the workflow
-        await executor.execute(workflow as Workflow, context, workflowReq)
+        await executor.execute(workflow as PayloadWorkflow, context, workflowReq)
 
         // Get the latest run for this workflow to get the run ID
         const runs = await payload.find({
@@ -255,7 +255,7 @@ export async function triggerWorkflowById(
 
     // Create executor and execute
     const executor = new WorkflowExecutor(payload, logger)
-    await executor.execute(workflow as Workflow, context, workflowReq)
+    await executor.execute(workflow as PayloadWorkflow, context, workflowReq)
 
     // Get the latest run to get the run ID
     const runs = await payload.find({

src/core/workflow-executor.ts

@@ -1,31 +1,39 @@
 import type { Payload, PayloadRequest } from 'payload'
 
+// We need to reference the generated types dynamically since they're not available at build time
+// Using generic types and casting where necessary
+export type PayloadWorkflow = {
+  id: number
+  name: string
+  description?: string | null
+  triggers?: Array<{
+    type?: string | null
+    collectionSlug?: string | null
+    operation?: string | null
+    condition?: string | null
+    [key: string]: unknown
+  }> | null
+  steps?: Array<{
+    step?: string | null
+    name?: string | null
+    input?: unknown
+    dependencies?: string[] | null
+    condition?: string | null
+    [key: string]: unknown
+  }> | null
+  [key: string]: unknown
+}
+
 import { JSONPath } from 'jsonpath-plus'
 
-export type Workflow = {
+// Helper type to extract workflow step data from the generated types
-  _version?: number
+export type WorkflowStep = NonNullable<PayloadWorkflow['steps']>[0] & {
-  id: string
+  name: string // Ensure name is always present for our execution logic
-  name: string
-  steps: WorkflowStep[]
-  triggers: WorkflowTrigger[]
 }
 
-export type WorkflowStep = {
+// Helper type to extract workflow trigger data from the generated types  
-  condition?: string
+export type WorkflowTrigger = NonNullable<PayloadWorkflow['triggers']>[0] & {
-  dependencies?: string[]
+  type: string // Ensure type is always present for our execution logic
-  input?: null | Record<string, unknown>
-  name: string
-  step: string
-}
-
-export interface WorkflowTrigger {
-  collection?: string
-  condition?: string
-  global?: string
-  globalOperation?: string
-  operation?: string
-  type: string
-  webhookPath?: string
 }
 
 export interface ExecutionContext {
@@ -154,7 +162,7 @@ export class WorkflowExecutor {
 
     try {
       // Resolve input data using JSONPath
-      const resolvedInput = this.resolveStepInput(step.input || {}, context)
+      const resolvedInput = this.resolveStepInput(step.input as Record<string, unknown> || {}, context)
       context.steps[stepName].input = resolvedInput
 
       if (!taskSlug) {
@@ -398,6 +406,47 @@ export class WorkflowExecutor {
     return resolved
   }
 
+  /**
+   * Safely serialize an object, handling circular references and non-serializable values
+   */
+  private safeSerialize(obj: unknown): unknown {
+    const seen = new WeakSet()
+    
+    const serialize = (value: unknown): unknown => {
+      if (value === null || typeof value !== 'object') {
+        return value
+      }
+      
+      if (seen.has(value as object)) {
+        return '[Circular Reference]'
+      }
+      
+      seen.add(value as object)
+      
+      if (Array.isArray(value)) {
+        return value.map(serialize)
+      }
+      
+      const result: Record<string, unknown> = {}
+      for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+        try {
+          // Skip non-serializable properties that are likely internal database objects
+          if (key === 'table' || key === 'schema' || key === '_' || key === '__') {
+            continue
+          }
+          result[key] = serialize(val)
+        } catch {
+          // Skip properties that can't be accessed or serialized
+          result[key] = '[Non-serializable]'
+        }
+      }
+      
+      return result
+    }
+    
+    return serialize(obj)
+  }
+
   /**
    * Update workflow run with current context
    */
@@ -407,14 +456,14 @@ export class WorkflowExecutor {
     req: PayloadRequest
   ): Promise<void> {
     const serializeContext = () => ({
-      steps: context.steps,
+      steps: this.safeSerialize(context.steps),
       trigger: {
         type: context.trigger.type,
         collection: context.trigger.collection,
-        data: context.trigger.data,
+        data: this.safeSerialize(context.trigger.data),
-        doc: context.trigger.doc,
+        doc: this.safeSerialize(context.trigger.doc),
         operation: context.trigger.operation,
-        previousDoc: context.trigger.previousDoc,
+        previousDoc: this.safeSerialize(context.trigger.previousDoc),
         triggeredAt: context.trigger.triggeredAt,
         user: context.trigger.req?.user
       }
@@ -431,7 +480,7 @@ export class WorkflowExecutor {
   }
 
   /**
-   * Evaluate a condition using JSONPath
+   * Evaluate a condition using JSONPath and comparison operators
    */
   public evaluateCondition(condition: string, context: ExecutionContext): boolean {
     this.logger.debug({
@@ -443,34 +492,94 @@ export class WorkflowExecutor {
     }, 'Starting condition evaluation')
 
     try {
-      const result = JSONPath({
+      // Check if this is a comparison expression
-        json: context,
+      const comparisonMatch = condition.match(/^(.+?)\s*(==|!=|>|<|>=|<=)\s*(.+)$/)
-        path: condition,
+      
-        wrap: false
+      if (comparisonMatch) {
-      })
+        const [, leftExpr, operator, rightExpr] = comparisonMatch
-
+        
-      this.logger.debug({
+        // Evaluate left side (should be JSONPath)
-        condition,
+        const leftValue = this.resolveJSONPathValue(leftExpr.trim(), context)
-        result,
+        
-        resultType: Array.isArray(result) ? 'array' : typeof result,
+        // Parse right side (could be string, number, boolean, or JSONPath)
-        resultLength: Array.isArray(result) ? result.length : undefined
+        const rightValue = this.parseConditionValue(rightExpr.trim(), context)
-      }, 'JSONPath evaluation result')
+        
-
+        this.logger.debug({
-      // Handle different result types
+          condition,
-      let finalResult: boolean
+          leftExpr: leftExpr.trim(),
-      if (Array.isArray(result)) {
+          leftValue,
-        finalResult = result.length > 0 && Boolean(result[0])
+          operator,
+          rightExpr: rightExpr.trim(),
+          rightValue,
+          leftType: typeof leftValue,
+          rightType: typeof rightValue
+        }, 'Evaluating comparison condition')
+        
+        // Perform comparison
+        let result: boolean
+        switch (operator) {
+          case '==':
+            result = leftValue === rightValue
+            break
+          case '!=':
+            result = leftValue !== rightValue
+            break
+          case '>':
+            result = Number(leftValue) > Number(rightValue)
+            break
+          case '<':
+            result = Number(leftValue) < Number(rightValue)
+            break
+          case '>=':
+            result = Number(leftValue) >= Number(rightValue)
+            break
+          case '<=':
+            result = Number(leftValue) <= Number(rightValue)
+            break
+          default:
+            throw new Error(`Unknown comparison operator: ${operator}`)
+        }
+        
+        this.logger.debug({
+          condition,
+          result,
+          leftValue,
+          rightValue,
+          operator
+        }, 'Comparison condition evaluation completed')
+        
+        return result
       } else {
-        finalResult = Boolean(result)
+        // Treat as simple JSONPath boolean evaluation
+        const result = JSONPath({
+          json: context,
+          path: condition,
+          wrap: false
+        })
+
+        this.logger.debug({
+          condition,
+          result,
+          resultType: Array.isArray(result) ? 'array' : typeof result,
+          resultLength: Array.isArray(result) ? result.length : undefined
+        }, 'JSONPath boolean evaluation result')
+
+        // Handle different result types
+        let finalResult: boolean
+        if (Array.isArray(result)) {
+          finalResult = result.length > 0 && Boolean(result[0])
+        } else {
+          finalResult = Boolean(result)
+        }
+
+        this.logger.debug({
+          condition,
+          finalResult,
+          originalResult: result
+        }, 'Boolean condition evaluation completed')
+
+        return finalResult
       }
-
-      this.logger.debug({
-        condition,
-        finalResult,
-        originalResult: result
-      }, 'Condition evaluation completed')
-
-      return finalResult
     } catch (error) {
       this.logger.warn({
         condition,
@@ -482,47 +591,119 @@ export class WorkflowExecutor {
       return false
     }
   }
+  
+  /**
+   * Resolve a JSONPath value from the context
+   */
+  private resolveJSONPathValue(expr: string, context: ExecutionContext): any {
+    if (expr.startsWith('$')) {
+      const result = JSONPath({
+        json: context,
+        path: expr,
+        wrap: false
+      })
+      // Return first result if array, otherwise the result itself
+      return Array.isArray(result) && result.length > 0 ? result[0] : result
+    }
+    return expr
+  }
+  
+  /**
+   * Parse a condition value (string literal, number, boolean, or JSONPath)
+   */
+  private parseConditionValue(expr: string, context: ExecutionContext): any {
+    // Handle string literals
+    if ((expr.startsWith('"') && expr.endsWith('"')) || (expr.startsWith("'") && expr.endsWith("'"))) {
+      return expr.slice(1, -1) // Remove quotes
+    }
+    
+    // Handle boolean literals
+    if (expr === 'true') return true
+    if (expr === 'false') return false
+    
+    // Handle number literals
+    if (/^-?\d+(\.\d+)?$/.test(expr)) {
+      return Number(expr)
+    }
+    
+    // Handle JSONPath expressions
+    if (expr.startsWith('$')) {
+      return this.resolveJSONPathValue(expr, context)
+    }
+    
+    // Return as string if nothing else matches
+    return expr
+  }
 
   /**
    * Execute a workflow with the given context
    */
-  async execute(workflow: Workflow, context: ExecutionContext, req: PayloadRequest): Promise<void> {
+  async execute(workflow: PayloadWorkflow, context: ExecutionContext, req: PayloadRequest): Promise<void> {
     this.logger.info({
       workflowId: workflow.id,
       workflowName: workflow.name
     }, 'Starting workflow execution')
 
     const serializeContext = () => ({
-      steps: context.steps,
+      steps: this.safeSerialize(context.steps),
       trigger: {
         type: context.trigger.type,
         collection: context.trigger.collection,
-        data: context.trigger.data,
+        data: this.safeSerialize(context.trigger.data),
-        doc: context.trigger.doc,
+        doc: this.safeSerialize(context.trigger.doc),
         operation: context.trigger.operation,
-        previousDoc: context.trigger.previousDoc,
+        previousDoc: this.safeSerialize(context.trigger.previousDoc),
         triggeredAt: context.trigger.triggeredAt,
         user: context.trigger.req?.user
       }
     })
 
+    this.logger.info({
+      workflowId: workflow.id,
+      workflowName: workflow.name,
+      contextSummary: {
+        triggerType: context.trigger.type,
+        triggerCollection: context.trigger.collection,
+        triggerOperation: context.trigger.operation,
+        hasDoc: !!context.trigger.doc,
+        userEmail: context.trigger.req?.user?.email
+      }
+    }, 'About to create workflow run record')
+
     // Create a workflow run record
-    const workflowRun = await this.payload.create({
+    let workflowRun;
-      collection: 'workflow-runs',
+    try {
-      data: {
+      workflowRun = await this.payload.create({
-        context: serializeContext(),
+        collection: 'workflow-runs',
-        startedAt: new Date().toISOString(),
+        data: {
-        status: 'running',
+          context: serializeContext(),
-        triggeredBy: context.trigger.req?.user?.email || 'system',
+          startedAt: new Date().toISOString(),
-        workflow: workflow.id,
+          status: 'running',
-        workflowVersion: workflow._version || 1
+          triggeredBy: context.trigger.req?.user?.email || 'system',
-      },
+          workflow: workflow.id,
-      req
+          workflowVersion: 1 // Default version since generated type doesn't have _version field
-    })
+        },
+        req
+      })
+
+      this.logger.info({
+        workflowRunId: workflowRun.id,
+        workflowId: workflow.id,
+        workflowName: workflow.name
+      }, 'Workflow run record created successfully')
+    } catch (error) {
+      this.logger.error({
+        error: error instanceof Error ? error.message : 'Unknown error',
+        errorStack: error instanceof Error ? error.stack : undefined,
+        workflowId: workflow.id,
+        workflowName: workflow.name
+      }, 'Failed to create workflow run record')
+      throw error
+    }
 
     try {
       // Resolve execution order based on dependencies
-      const executionBatches = this.resolveExecutionOrder(workflow.steps)
+      const executionBatches = this.resolveExecutionOrder(workflow.steps as WorkflowStep[] || [])
 
       this.logger.info({
         batchSizes: executionBatches.map(batch => batch.length),
@@ -606,6 +787,12 @@ export class WorkflowExecutor {
     previousDoc: unknown,
     req: PayloadRequest
   ): Promise<void> {
+    this.logger.info({
+      collection,
+      operation,
+      docId: (doc as any)?.id
+    }, 'executeTriggeredWorkflows called')
+    
     try {
       // Find workflows with matching triggers
       const workflows = await this.payload.find({
@@ -614,23 +801,60 @@ export class WorkflowExecutor {
         limit: 100,
         req
       })
+      
+      this.logger.info({
+        workflowCount: workflows.docs.length
+      }, 'Found workflows to check')
 
       for (const workflow of workflows.docs) {
         // Check if this workflow has a matching trigger
         const triggers = workflow.triggers as Array<{
-          collection: string
+          collection?: string
+          collectionSlug?: string
           condition?: string
           operation: string
           type: string
         }>
+        
+        this.logger.debug({
+          workflowId: workflow.id,
+          workflowName: workflow.name,
+          triggerCount: triggers?.length || 0,
+          triggers: triggers?.map(t => ({
+            type: t.type,
+            collection: t.collection,
+            collectionSlug: t.collectionSlug,
+            operation: t.operation
+          }))
+        }, 'Checking workflow triggers')
 
         const matchingTriggers = triggers?.filter(trigger =>
           trigger.type === 'collection-trigger' &&
-          trigger.collection === collection &&
+          (trigger.collection === collection || trigger.collectionSlug === collection) &&
           trigger.operation === operation
         ) || []
+        
+        this.logger.info({
+          workflowId: workflow.id,
+          workflowName: workflow.name,
+          matchingTriggerCount: matchingTriggers.length,
+          targetCollection: collection,
+          targetOperation: operation
+        }, 'Matching triggers found')
 
         for (const trigger of matchingTriggers) {
+          this.logger.info({
+            workflowId: workflow.id,
+            workflowName: workflow.name,
+            triggerDetails: {
+              type: trigger.type,
+              collection: trigger.collection,
+              collectionSlug: trigger.collectionSlug,
+              operation: trigger.operation,
+              hasCondition: !!trigger.condition
+            }
+          }, 'Processing matching trigger - about to execute workflow')
+
           // Create execution context for condition evaluation
           const context: ExecutionContext = {
             steps: {},
@@ -689,7 +913,7 @@ export class WorkflowExecutor {
           }, 'Triggering workflow')
 
           // Execute the workflow
-          await this.execute(workflow as Workflow, context, req)
+          await this.execute(workflow as PayloadWorkflow, context, req)
         }
       }
     } catch (error) {

src/index.ts

@@ -1,10 +1,19 @@
 // Main export contains only types and client-safe utilities
 // Server-side functions are exported via '@xtr-dev/payload-automation/server'
 
-// Types only - safe for client bundling
+// Pure types only - completely safe for client bundling
-export type { CustomTriggerOptions, TriggerResult } from './core/trigger-custom-workflow.js'
+export type {
-export type { ExecutionContext, Workflow, WorkflowStep, WorkflowTrigger } from './core/workflow-executor.js'
+  CustomTriggerOptions,
-export type { WorkflowsPluginConfig } from './plugin/config-types.js'
+  TriggerResult,
+  ExecutionContext,
+  WorkflowsPluginConfig
+} from './types/index.js'
+
+export type {
+  PayloadWorkflow as Workflow,
+  WorkflowStep,
+  WorkflowTrigger
+} from './core/workflow-executor.js'
 
 // Server-side functions are NOT re-exported here to avoid bundling issues
 // Import server-side functions from the /server export instead

src/plugin/cron-scheduler.ts

@@ -2,7 +2,7 @@ import type {Config, Payload, TaskConfig} from 'payload'
 
 import cron from 'node-cron'
 
-import {type Workflow, WorkflowExecutor} from '../core/workflow-executor.js'
+import {type PayloadWorkflow, WorkflowExecutor} from '../core/workflow-executor.js'
 import {getConfigLogger} from './logger.js'
 
 /**
@@ -101,7 +101,7 @@ export function generateCronTasks(config: Config): void {
         }
 
         // Execute the workflow
-        await executor.execute(workflow as Workflow, context, req)
+        await executor.execute(workflow as PayloadWorkflow, context, req)
 
         // Re-queue the job for the next scheduled execution if cronExpression is provided
         if (cronExpression) {

src/plugin/init-global-hooks.ts

@@ -1,7 +1,7 @@
 import type { Payload, PayloadRequest } from "payload"
 import type { Logger } from "pino"
 
-import type { WorkflowExecutor, Workflow } from "../core/workflow-executor.js"
+import type { WorkflowExecutor, PayloadWorkflow } from "../core/workflow-executor.js"
 
 export function initGlobalHooks(payload: Payload, logger: Payload['logger'], executor: WorkflowExecutor) {
   // Get all globals from the config
@@ -100,7 +100,7 @@ async function executeTriggeredGlobalWorkflows(
       }
 
       // Execute the workflow
-      await executor.execute(workflow as Workflow, context, req)
+      await executor.execute(workflow as PayloadWorkflow, context, req)
     }
   } catch (error) {
     logger.error({

src/plugin/init-webhook.ts

@@ -1,6 +1,6 @@
 import type {Config, PayloadRequest} from 'payload'
 
-import {type Workflow, WorkflowExecutor} from '../core/workflow-executor.js'
+import {type PayloadWorkflow, WorkflowExecutor} from '../core/workflow-executor.js'
 import {getConfigLogger, initializeLogger} from './logger.js'
 
 export function initWebhookEndpoint(config: Config, webhookPrefix = 'webhook'): void {
@@ -110,7 +110,7 @@ export function initWebhookEndpoint(config: Config, webhookPrefix = 'webhook'):
             }
 
             // Execute the workflow
-            await executor.execute(workflow as Workflow, context, req)
+            await executor.execute(workflow as PayloadWorkflow, context, req)
 
             return { status: 'triggered', workflowId: workflow.id }
           } catch (error) {

src/types/index.ts

@@ -0,0 +1,41 @@
+// Pure type definitions for client-safe exports
+// This file contains NO runtime code and can be safely bundled
+
+export interface CustomTriggerOptions {
+  workflowId: string
+  triggerData?: any
+  req?: any // PayloadRequest type, but avoiding import to keep this client-safe
+}
+
+export interface TriggerResult {
+  success: boolean
+  runId?: string
+  error?: string
+}
+
+export interface ExecutionContext {
+  trigger: {
+    type: string
+    doc?: any
+    data?: any
+  }
+  steps: Record<string, {
+    output?: any
+    state: 'pending' | 'running' | 'succeeded' | 'failed'
+  }>
+  payload: any // Payload instance
+  req: any // PayloadRequest
+}
+
+// NOTE: Workflow, WorkflowStep, and WorkflowTrigger types are now imported from the generated PayloadCMS types
+// These interfaces have been removed to avoid duplication and inconsistencies
+// Import them from 'payload' or the generated payload-types.ts file instead
+
+export interface WorkflowsPluginConfig {
+  collections?: string[]
+  globals?: string[]
+  logging?: {
+    level?: 'debug' | 'info' | 'warn' | 'error'
+    enabled?: boolean
+  }
+}