WIP: Refactor triggers to TriggerConfig pattern

- Convert webhook, global, and cron triggers to use TriggerConfig pattern like collectionTrigger
- Simplify trigger slug names (remove '-trigger' suffix)
- Update validation to use new slug names
- Add perfectionist/sort-exports rule disable
- Note: Workflow.ts integration still needs fixes for type compatibility

eslint.config.js

@@ -30,6 +30,7 @@ export default [
       'no-console': 'off',
       'perfectionist/sort-object-types': 'off',
       'perfectionist/sort-objects': 'off',
+      'perfectionist/sort-exports': 'off',
     },
   },
   {

src/collections/Workflow.ts

@@ -1,180 +1,178 @@
 import type {CollectionConfig, Field} from 'payload'
 
 import type {WorkflowsPluginConfig} from "../plugin/config-types.js"
+
 import {
-  getCollectionTriggerFields,
+  collectionTrigger,
-  getCronTriggerFields,
+  cronTrigger,
-  getGlobalTriggerFields,
+  globalTrigger,
-  getWebhookTriggerFields
+  webhookTrigger
 } from '../triggers/index.js'
+import {trigger} from '../triggers/helpers.js'
 
-export const createWorkflowCollection: <T extends string>(options: WorkflowsPluginConfig<T>) => CollectionConfig = ({
+export const createWorkflowCollection: <T extends string>(options: WorkflowsPluginConfig<T>) => CollectionConfig = (options) => {
-                                                                                                        collectionTriggers,
+  const {steps, collectionTriggers} = options
-                                                                                                        steps,
+  const triggers = (options.triggers || []).map(t => t(options))
-                                                                                                        triggers
+  return {
-                                                                                                      }) => ({
+    slug: 'workflows',
-  slug: 'workflows',
+      access: {
-  access: {
     create: () => true,
-    delete: () => true,
+      delete: () => true,
-    read: () => true,
+      read: () => true,
-    update: () => true,
+      update: () => true,
   },
-  admin: {
+    admin: {
-    defaultColumns: ['name', 'updatedAt'],
+      defaultColumns: ['name', 'updatedAt'],
-    description: 'Create and manage automated workflows.',
+        description: 'Create and manage automated workflows.',
-    group: 'Automation',
+        group: 'Automation',
-    useAsTitle: 'name',
+        useAsTitle: 'name',
-  },
+    },
-  fields: [
+    fields: [
-    {
+      {
-      name: 'name',
+        name: 'name',
-      type: 'text',
+        type: 'text',
-      admin: {
+        admin: {
-        description: 'Human-readable name for the workflow',
+          description: 'Human-readable name for the workflow',
+        },
+        required: true,
       },
-      required: true,
+      {
-    },
+        name: 'description',
-    {
+        type: 'textarea',
-      name: 'description',
+        admin: {
-      type: 'textarea',
+          description: 'Optional description of what this workflow does',
-      admin: {
+        },
-        description: 'Optional description of what this workflow does',
       },
-    },
+      {
-    {
+        name: 'executionStatus',
-      name: 'executionStatus',
+        type: 'ui',
-      type: 'ui',
+        admin: {
-      admin: {
+          components: {
-        components: {
+            Field: '@xtr-dev/payload-automation/client#WorkflowExecutionStatus'
-          Field: '@xtr-dev/payload-automation/client#WorkflowExecutionStatus'
-        },
-        condition: (data) => !!data?.id // Only show for existing workflows
-      }
-    },
-    {
-      name: 'triggers',
-      type: 'array',
-      fields: [
-        {
-          name: 'type',
-          type: 'select',
-          options: [
-            'collection-trigger',
-            'webhook-trigger',
-            'global-trigger',
-            'cron-trigger',
-            ...(triggers || []).map(t => t.slug)
-          ]
-        },
-        {
-          name: 'parameters',
-          type: 'json',
-          admin: {
-            hidden: true,
           },
-          defaultValue: {}
+          condition: (data) => !!data?.id // Only show for existing workflows
-        },
+        }
-        // Virtual fields for built-in triggers
+      },
-        ...getCollectionTriggerFields(collectionTriggers),
+      {
-        ...getWebhookTriggerFields(),
+        name: 'triggers',
-        ...getGlobalTriggerFields(),
+        type: 'array',
-        ...getCronTriggerFields(),
+        fields: [
-        {
+          {
-          name: 'condition',
+            name: 'type',
-          type: 'text',
+            type: 'select',
-          admin: {
+            options: [
-            description: 'JSONPath expression that must evaluate to true for this trigger to execute the workflow (e.g., "$.trigger.doc.status == \'published\'")'
+              ...(triggers || []).map(t => t.slug)
+            ]
           },
-          required: false
+          {
-        },
+            name: 'parameters',
-        // Virtual fields for custom triggers
+            type: 'json',
-        // Note: Custom trigger fields from trigger-helpers already have unique names
-        // We just need to pass them through without modification
-        ...(triggers || []).flatMap(t => (t.inputs || []))
-      ]
-    },
-    {
-      name: 'steps',
-      type: 'array',
-      fields: [
-        {
-          type: 'row',
-          fields: [
-            {
-              name: 'step',
-              type: 'select',
-              options: steps.map(t => t.slug)
-            },
-            {
-              name: 'name',
-              type: 'text',
-            }
-          ]
-        },
-        ...(steps || []).flatMap(step => (step.inputSchema || []).map(field => {
-          const originalName = (field as any).name;
-          const resultField: any = {
-            ...field,
-            // Prefix field name with step slug to avoid conflicts
-            name: `__step_${step.slug}_${originalName}`,
             admin: {
-              ...(field.admin || {}),
+              hidden: true,
-              condition: (...args: any[]) => args[1]?.step === step.slug && (
-                (field.admin as any)?.condition ?
-                  (field.admin as any).condition.call(this, ...args) :
-                  true
-              ),
             },
-            virtual: true,
+            defaultValue: {}
-          };
+          },
-
+          // Virtual fields for built-in triggers
-          // Add hooks to store/retrieve from the step's input data
+          ...trigger({slug: 'collection', fields: collectionTrigger(options).fields}).fields,
-          resultField.hooks = {
+          ...trigger({slug: 'webhook', fields: webhookTrigger().fields}).fields,
-            ...((field as any).hooks || {}),
+          ...trigger({slug: 'global', fields: globalTrigger().fields}).fields,
-            afterRead: [
+          ...trigger({slug: 'cron', fields: cronTrigger().fields}).fields,
-              ...(((field as any).hooks)?.afterRead || []),
+          {
-              ({ siblingData }: any) => {
+            name: 'condition',
-                // Read from step input data using original field name
+            type: 'text',
-                return siblingData?.[originalName] || (field as any).defaultValue;
+            admin: {
-              }
+              description: 'JSONPath expression that must evaluate to true for this trigger to execute the workflow (e.g., "$.trigger.doc.status == \'published\'")'
-            ],
+            },
-            beforeChange: [
+            required: false
-              ...(((field as any).hooks)?.beforeChange || []),
+          },
-              ({ siblingData, value }: any) => {
+          // Virtual fields for custom triggers
-                // Store in step data using original field name
+          // Note: Custom trigger fields from trigger-helpers already have unique names
-                siblingData[originalName] = value;
+          // We just need to pass them through without modification
-                return undefined; // Don't store the prefixed field
+          ...(triggers || []).flatMap(t => (t.fields || []))
+        ]
+      },
+      {
+        name: 'steps',
+        type: 'array',
+        fields: [
+          {
+            type: 'row',
+            fields: [
+              {
+                name: 'step',
+                type: 'select',
+                options: steps.map(t => t.slug)
+              },
+              {
+                name: 'name',
+                type: 'text',
               }
             ]
-          };
+          },
+          ...(steps || []).flatMap(step => (step.inputSchema || []).map(field => {
+            const originalName = (field as any).name;
+            const resultField: any = {
+              ...field,
+              // Prefix field name with step slug to avoid conflicts
+              name: `__step_${step.slug}_${originalName}`,
+              admin: {
+                ...(field.admin || {}),
+                condition: (...args: any[]) => args[1]?.step === step.slug && (
+                  (field.admin as any)?.condition ?
+                    (field.admin as any).condition.call(this, ...args) :
+                    true
+                ),
+              },
+              virtual: true,
+            };
 
-          return resultField as Field;
+            // Add hooks to store/retrieve from the step's input data
-        })),
+            resultField.hooks = {
-        {
+              ...((field as any).hooks || {}),
-          name: 'dependencies',
+              afterRead: [
-          type: 'text',
+                ...(((field as any).hooks)?.afterRead || []),
-          admin: {
+                ({ siblingData }: any) => {
-            description: 'Step names that must complete before this step can run'
+                  // Read from step input data using original field name
+                  return siblingData?.[originalName] || (field as any).defaultValue;
+                }
+              ],
+              beforeChange: [
+                ...(((field as any).hooks)?.beforeChange || []),
+                ({ siblingData, value }: any) => {
+                  // Store in step data using original field name
+                  siblingData[originalName] = value;
+                  return undefined; // Don't store the prefixed field
+                }
+              ]
+            };
+
+            return resultField as Field;
+          })),
+          {
+            name: 'dependencies',
+            type: 'text',
+            admin: {
+              description: 'Step names that must complete before this step can run'
+            },
+            hasMany: true,
+            required: false
           },
-          hasMany: true,
+          {
-          required: false
+            name: 'condition',
-        },
+            type: 'text',
-        {
+            admin: {
-          name: 'condition',
+              description: 'JSONPath expression that must evaluate to true for this step to execute (e.g., "$.trigger.doc.status == \'published\'")'
-          type: 'text',
+            },
-          admin: {
+            required: false
-            description: 'JSONPath expression that must evaluate to true for this step to execute (e.g., "$.trigger.doc.status == \'published\'")'
           },
-          required: false
+        ],
-        },
+      }
-      ],
+    ],
-    }
+      versions: {
-  ],
-  versions: {
     drafts: {
       autosave: false,
     },
     maxPerDoc: 10,
   },
-})
+  }
+}

src/plugin/config-types.ts

@@ -1,4 +1,6 @@
-import type {Field, TaskConfig} from "payload"
+import type {TaskConfig} from "payload"
+
+import type {Trigger} from "../triggers/types.js"
 
 export type CollectionTriggerConfigCrud = {
   create?: true
@@ -9,10 +11,7 @@ export type CollectionTriggerConfigCrud = {
 
 export type CollectionTriggerConfig = CollectionTriggerConfigCrud | true
 
-export type CustomTriggerConfig = {
+export type TriggerConfig = <T extends string>(config: WorkflowsPluginConfig<T>) => Trigger
-  inputs?: Field[]
-  slug: string,
-}
 
 export type WorkflowsPluginConfig<TSlug extends string> = {
   collectionTriggers: {
@@ -20,6 +19,6 @@ export type WorkflowsPluginConfig<TSlug extends string> = {
   }
   enabled?: boolean
   steps: TaskConfig<string>[],
-  triggers?: CustomTriggerConfig[]
+  triggers?: TriggerConfig[]
   webhookPrefix?: string
 }

src/triggers/collection-trigger.ts

@@ -1,19 +1,14 @@
-import type {Field} from 'payload'
+import type {TriggerConfig} from '../plugin/config-types.js'
 
-import type { WorkflowsPluginConfig } from '../plugin/config-types.js'
+export const collectionTrigger: TriggerConfig = ({collectionTriggers}) => ({
-
+  slug: 'collection',
-import {triggerField} from "./helpers.js"
+  fields: [
-
+    {
-export function getCollectionTriggerFields<T extends string>(
-  collectionTriggers: WorkflowsPluginConfig<T>['collectionTriggers']
-): Field[] {
-  return [
-    triggerField({
       name: 'collectionSlug',
       type: 'select',
       options: Object.keys(collectionTriggers || {}),
-    }),
+    },
-    triggerField({
+    {
       name: 'operation',
       type: 'select',
       options: [
@@ -22,6 +17,6 @@ export function getCollectionTriggerFields<T extends string>(
         'read',
         'update',
       ],
-    })
+    }
   ]
-}
+})

src/triggers/cron-trigger.ts

@@ -1,25 +1,23 @@
-import type {Field} from 'payload'
+import type {TriggerConfig} from '../plugin/config-types.js'
 
-import {triggerField} from "./helpers.js"
+export const cronTrigger: TriggerConfig = () => ({
-
+  slug: 'cron',
-export function getCronTriggerFields(): Field[] {
+  fields: [
-  return [
+    {
-    triggerField({
       name: 'cronExpression',
       type: 'text',
       admin: {
-        condition: (_, siblingData) => siblingData?.type === 'cron-trigger',
         description: 'Cron expression for scheduled execution (e.g., "0 0 * * *" for daily at midnight)',
         placeholder: '0 0 * * *'
       },
       validate: (value: any, {siblingData}: any) => {
         const cronValue = value || siblingData?.parameters?.cronExpression
-        if (siblingData?.type === 'cron-trigger' && !cronValue) {
+        if (siblingData?.type === 'cron' && !cronValue) {
           return 'Cron expression is required for cron triggers'
         }
 
         // Validate cron expression format if provided
-        if (siblingData?.type === 'cron-trigger' && cronValue) {
+        if (siblingData?.type === 'cron' && cronValue) {
           // Basic format validation - should be 5 parts separated by spaces
           const cronParts = cronValue.trim().split(/\s+/)
           if (cronParts.length !== 5) {
@@ -32,19 +30,18 @@ export function getCronTriggerFields(): Field[] {
 
         return true
       },
-    }),
+    },
-    triggerField({
+    {
       name: 'timezone',
       type: 'text',
       admin: {
-        condition: (_, siblingData) => siblingData?.type === 'cron-trigger',
         description: 'Timezone for cron execution (e.g., "America/New_York", "Europe/London"). Defaults to UTC.',
         placeholder: 'UTC'
       },
       defaultValue: 'UTC',
       validate: (value: any, {siblingData}: any) => {
         const tzValue = value || siblingData?.parameters?.timezone
-        if (siblingData?.type === 'cron-trigger' && tzValue) {
+        if (siblingData?.type === 'cron' && tzValue) {
           try {
             // Test if timezone is valid by trying to create a date with it
             new Intl.DateTimeFormat('en', {timeZone: tzValue})
@@ -55,6 +52,6 @@ export function getCronTriggerFields(): Field[] {
         }
         return true
       },
-    })
+    }
   ]
-}
+})

src/triggers/global-trigger.ts

@@ -1,28 +1,25 @@
-import type {Field} from 'payload'
+import type {TriggerConfig} from '../plugin/config-types.js'
 
-import {triggerField} from "./helpers.js"
+export const globalTrigger: TriggerConfig = () => ({
-
+  slug: 'global',
-export function getGlobalTriggerFields(): Field[] {
+  fields: [
-  return [
+    {
-    triggerField({
       name: 'global',
       type: 'select',
       admin: {
-        condition: (_, siblingData) => siblingData?.type === 'global-trigger',
         description: 'Global that triggers the workflow',
       },
       options: [], // Will be populated dynamically based on available globals
-    }),
+    },
-    triggerField({
+    {
       name: 'globalOperation',
       type: 'select',
       admin: {
-        condition: (_, siblingData) => siblingData?.type === 'global-trigger',
         description: 'Global operation that triggers the workflow',
       },
       options: [
         'update'
       ],
-    })
+    }
   ]
-}
+})

src/triggers/helpers.ts

@@ -1,12 +1,10 @@
-import type {Field, TextField, SelectField} from "payload"
+import type {Field} from "payload"
 
 import type {Trigger} from "./types.js"
 
-type FieldWithName = TextField | SelectField | (Field & { name: string })
-
 type Options = {
   slug: string,
-  fields?: FieldWithName[]
+  fields?: ({name: string} & Field)[]
 }
 
 export const trigger = ({
@@ -15,18 +13,18 @@ export const trigger = ({
                               }: Options): Trigger => {
   return {
     slug,
-    fields: (fields || []).map(triggerField) as Field[]
+    fields: (fields || []).map(f => triggerField(slug, f))
   }
 }
 
-export const triggerField = (field: FieldWithName): Field => ({
+export const triggerField = (slug: string, field: {name: string} & Field): Field => ({
   ...field,
   name: '__trigger_' + field.name,
   admin: {
-    ...(field.admin as any || {}),
+    ...(field.admin as unknown || {}),
     condition: (_, siblingData, __) => {
       const previous = field.admin?.condition?.call(null, _, siblingData, __)
-      return previous !== false // Preserve existing condition if it exists
+      return previous || (siblingData?.type === slug)
     },
   },
   hooks: {

src/triggers/index.ts

@@ -1,4 +1,4 @@
-export { getCollectionTriggerFields } from './collection-trigger.js'
+export { collectionTrigger } from './collection-trigger.js'
-export { getCronTriggerFields } from './cron-trigger.js'
+export { cronTrigger } from './cron-trigger.js'
-export { getGlobalTriggerFields } from './global-trigger.js'
+export { globalTrigger } from './global-trigger.js'
-export { getWebhookTriggerFields } from './webhook-trigger.js'
+export { webhookTrigger } from './webhook-trigger.js'

src/triggers/webhook-trigger.ts

@@ -1,22 +1,20 @@
-import type {Field} from 'payload'
+import type {TriggerConfig} from '../plugin/config-types.js'
 
-import {triggerField} from "./helpers.js"
+export const webhookTrigger: TriggerConfig = () => ({
-
+  slug: 'webhook',
-export function getWebhookTriggerFields(): Field[] {
+  fields: [
-  return [
+    {
-    triggerField({
       name: 'webhookPath',
       type: 'text',
       admin: {
-        condition: (_, siblingData) => siblingData?.type === 'webhook-trigger',
         description: 'URL path for the webhook (e.g., "my-webhook"). Full URL will be /api/workflows-webhook/my-webhook',
       },
       validate: (value: any, {siblingData}: any) => {
-        if (siblingData?.type === 'webhook-trigger' && !value && !siblingData?.parameters?.webhookPath) {
+        if (siblingData?.type === 'webhook' && !value && !siblingData?.parameters?.webhookPath) {
           return 'Webhook path is required for webhook triggers'
         }
         return true
       },
-    })
+    }
   ]
-}
+})