Refactor trigger helpers to single simplified function

- Replace multiple helper functions with single createTriggerField function
- createTriggerField takes a standard PayloadCMS field and adds virtual storage hooks
- Simplify trigger presets to use the new createTrigger helper
- Update exports to match new simplified API
- Cleaner, more maintainable code with less boilerplate

src/exports/helpers.ts

@@ -3,31 +3,29 @@
  * 
  * @example
  * ```typescript
- * import { createTrigger, webhookTrigger } from '@xtr-dev/payload-automation/helpers'
+ * import { createTrigger, createTriggerField, webhookTrigger } from '@xtr-dev/payload-automation/helpers'
  * 
- * // Simple trigger
+ * // Simple trigger with array of fields
- * const myTrigger = createTrigger('my-trigger').parameters({
+ * const myTrigger = createTrigger('my-trigger', [
- *   apiKey: { type: 'text', required: true },
+ *   { name: 'apiKey', type: 'text', required: true },
- *   timeout: { type: 'number', defaultValue: 30 }
+ *   { name: 'timeout', type: 'number', defaultValue: 30 }
- * })
+ * ])
  * 
- * // Webhook trigger with presets
+ * // Single field with virtual storage
+ * const field = createTriggerField(
+ *   { name: 'webhookUrl', type: 'text', required: true },
+ *   'my-trigger'
+ * )
+ * 
+ * // Webhook trigger preset
  * const orderWebhook = webhookTrigger('order-webhook')
- *   .parameter('orderTypes', {
- *     type: 'select',
- *     hasMany: true,
- *     options: ['regular', 'subscription']
- *   })
- *   .build()
  * ```
  */
 
 // Core helpers
 export {
-  createTriggerParameter,
+  createTriggerField,
-  createTriggerParameters,
+  createTrigger
-  createTrigger,
-  createAdvancedTrigger
 } from '../utils/trigger-helpers.js'
 
 // Preset builders
@@ -38,10 +36,3 @@ export {
   manualTrigger,
   apiTrigger
 } from '../utils/trigger-presets.js'
-
-// Common parameter sets for extending
-export {
-  webhookParameters,
-  cronParameters,
-  eventParameters
-} from '../utils/trigger-presets.js'

src/utils/trigger-helpers.ts

@@ -2,137 +2,132 @@ import type { Field } from 'payload'
 import type { CustomTriggerConfig } from '../plugin/config-types.js'
 
 /**
- * Helper function to create a virtual trigger parameter field
+ * Creates a virtual field for a trigger parameter that stores its value in the parameters JSON field
- * Handles the boilerplate for storing/reading from the parameters JSON field
+ * 
+ * @param field - Standard PayloadCMS field configuration (must be a data field with a name)
+ * @param triggerSlug - The slug of the trigger this field belongs to
+ * @returns Modified field with virtual storage hooks and proper naming
+ * 
+ * @example
+ * ```typescript
+ * const myTrigger: CustomTriggerConfig = {
+ *   slug: 'my-trigger',
+ *   inputs: [
+ *     createTriggerField({
+ *       name: 'webhookUrl',
+ *       type: 'text',
+ *       required: true,
+ *       admin: {
+ *         description: 'URL to call when triggered'
+ *       }
+ *     }, 'my-trigger')
+ *   ]
+ * }
+ * ```
  */
-export function createTriggerParameter(
+export function createTriggerField(field: any, triggerSlug: string): Field {
-  name: string,
+  const originalName = field.name
-  fieldConfig: any, // Use any to allow flexible field configurations
+  if (!originalName) {
-  triggerSlug: string
+    throw new Error('Field must have a name property')
-): Field {
+  }
-  // Create a unique field name by prefixing with trigger slug
-  const uniqueFieldName = `__trigger_${triggerSlug}_${name}`
 
-  return {
+  // Create a unique field name by prefixing with trigger slug
-    ...fieldConfig,
+  const uniqueFieldName = `__trigger_${triggerSlug}_${originalName}`
+  
+  const resultField: any = {
+    ...field,
     name: uniqueFieldName,
     virtual: true,
     admin: {
-      ...fieldConfig.admin,
+      ...(field.admin || {}),
-      condition: (_, siblingData) => siblingData?.type === triggerSlug && (
+      condition: (data: any, siblingData: any) => {
-        fieldConfig.admin?.condition ? 
+        // Only show this field when the trigger type matches
-          fieldConfig.admin.condition(_, siblingData) : 
+        const triggerMatches = siblingData?.type === triggerSlug
-          true
+        
-      )
+        // If the original field had a condition, combine it with our trigger condition
+        if (field.admin?.condition) {
+          return triggerMatches && field.admin.condition(data, siblingData)
+        }
+        
+        return triggerMatches
+      }
     },
     hooks: {
-      ...fieldConfig.hooks,
+      ...(field.hooks || {}),
       afterRead: [
-        ...(fieldConfig.hooks?.afterRead || []),
+        ...(field.hooks?.afterRead || []),
-        ({ siblingData }) => siblingData?.parameters?.[name] || fieldConfig.defaultValue
+        ({ siblingData }: any) => {
+          // Read the value from the parameters JSON field
+          return siblingData?.parameters?.[originalName] ?? field.defaultValue
+        }
       ],
       beforeChange: [
-        ...(fieldConfig.hooks?.beforeChange || []),
+        ...(field.hooks?.beforeChange || []),
-        ({ value, siblingData }) => {
+        ({ value, siblingData }: any) => {
-          if (!siblingData.parameters) siblingData.parameters = {}
+          // Store the value in the parameters JSON field
-          siblingData.parameters[name] = value
+          if (!siblingData.parameters) {
+            siblingData.parameters = {}
+          }
+          siblingData.parameters[originalName] = value
           return undefined // Virtual field, don't store directly
         }
       ]
-    },
+    }
-    validate: fieldConfig.validate || fieldConfig.required ? 
+  }
-      (value: any, args: any) => {
-        const paramValue = value ?? args.siblingData?.parameters?.[name]
 
-        // Check required
+  // Only add validate if the field supports it (data fields)
-        if (fieldConfig.required && args.siblingData?.type === triggerSlug && !paramValue) {
+  if (field.validate || field.required) {
-          return `${fieldConfig.admin?.description || name} is required for ${triggerSlug}`
+    resultField.validate = (value: any, args: any) => {
-        }
+      const paramValue = value ?? args.siblingData?.parameters?.[originalName]
       
-        // Run original validation if present
+      // Check required validation
-        return fieldConfig.validate?.(paramValue, args) ?? true
+      if (field.required && args.siblingData?.type === triggerSlug && !paramValue) {
-      } : 
+        const label = field.label || field.admin?.description || originalName
-      undefined
+        return `${label} is required for ${triggerSlug}`
-  } as Field
+      }
+      
+      // Run original validation if present
+      if (field.validate) {
+        return field.validate(paramValue, args)
+      }
+      
+      return true
+    }
+  }
+
+  return resultField as Field
 }
 
 /**
- * Helper to create multiple trigger parameter fields at once
+ * Creates a custom trigger configuration with the provided fields
+ * 
+ * @param slug - Unique identifier for the trigger
+ * @param fields - Array of PayloadCMS fields that will be shown as trigger parameters
+ * @returns Complete trigger configuration
+ * 
+ * @example
+ * ```typescript
+ * const webhookTrigger = createTrigger('webhook', [
+ *   {
+ *     name: 'url',
+ *     type: 'text',
+ *     required: true,
+ *     admin: {
+ *       description: 'Webhook URL'
+ *     }
+ *   },
+ *   {
+ *     name: 'method',
+ *     type: 'select',
+ *     options: ['GET', 'POST', 'PUT', 'DELETE'],
+ *     defaultValue: 'POST'
+ *   }
+ * ])
+ * ```
  */
-export function createTriggerParameters(
+export function createTrigger(slug: string, fields: Field[]): CustomTriggerConfig {
-  triggerSlug: string,
-  parameters: Record<string, any>
-): Field[] {
-  return Object.entries(parameters).map(([name, fieldConfig]) => 
-    createTriggerParameter(name, fieldConfig, triggerSlug)
-  )
-}
-
-/**
- * Main trigger builder function that creates a fluent API for defining triggers
- */
-export function createTrigger<TSlug extends string>(slug: TSlug) {
   return {
-    /**
-     * Define parameters for this trigger using a clean object syntax
-     * @param paramConfig - Object where keys are parameter names and values are Field configs
-     * @returns Complete CustomTriggerConfig ready for use
-     */
-    parameters(paramConfig: Record<string, any>): CustomTriggerConfig {
-      return {
-        slug,
-        inputs: Object.entries(paramConfig).map(([name, fieldConfig]) => 
-          createTriggerParameter(name, fieldConfig, slug)
-        )
-      }
-    }
-  }
-}
-
-/**
- * Advanced trigger builder with chainable methods for more complex scenarios
- */
-export function createAdvancedTrigger<TSlug extends string>(slug: TSlug) {
-  const builder = {
     slug,
-    _parameters: {} as Record<string, any>,
+    inputs: fields.map(field => createTriggerField(field, slug))
-    
-    /**
-     * Set all parameters at once
-     */
-    parameters(paramConfig: Record<string, any>) {
-      this._parameters = paramConfig
-      return this
-    },
-    
-    /**
-     * Add a single parameter
-     */
-    parameter(name: string, fieldConfig: any) {
-      this._parameters[name] = fieldConfig
-      return this
-    },
-    
-    /**
-     * Extend with existing parameter sets (useful for common patterns)
-     */
-    extend(baseParameters: Record<string, any>) {
-      this._parameters = { ...baseParameters, ...this._parameters }
-      return this
-    },
-    
-    /**
-     * Build the final trigger configuration
-     */
-    build(): CustomTriggerConfig {
-      return {
-        slug: this.slug,
-        inputs: Object.entries(this._parameters).map(([name, fieldConfig]) => 
-          createTriggerParameter(name, fieldConfig, this.slug)
-        )
-      }
-    }
   }
-  
-  return builder
 }

src/utils/trigger-presets.ts

@@ -1,88 +1,5 @@
-import { createAdvancedTrigger } from './trigger-helpers.js'
+import { createTrigger } from './trigger-helpers.js'
-
+import type { CustomTriggerConfig } from '../plugin/config-types.js'
-/**
- * Common parameter sets for reuse across different triggers
- */
-
-export const webhookParameters: Record<string, any> = {
-  path: {
-    type: 'text',
-    required: true,
-    admin: {
-      description: 'URL path for the webhook endpoint (e.g., "my-webhook")'
-    },
-    validate: (value: any) => {
-      if (typeof value === 'string' && value.includes(' ')) {
-        return 'Webhook path cannot contain spaces'
-      }
-      return true
-    }
-  },
-  secret: {
-    type: 'text',
-    admin: {
-      description: 'Secret key for webhook signature validation (optional but recommended)'
-    }
-  },
-  headers: {
-    type: 'json',
-    admin: {
-      description: 'Expected HTTP headers for validation (JSON object)'
-    }
-  }
-}
-
-export const cronParameters: Record<string, any> = {
-  expression: {
-    type: 'text',
-    required: true,
-    admin: {
-      description: 'Cron expression for scheduling (e.g., "0 9 * * 1" for every Monday at 9 AM)',
-      placeholder: '0 9 * * 1'
-    }
-  },
-  timezone: {
-    type: 'text',
-    defaultValue: 'UTC',
-    admin: {
-      description: 'Timezone for cron execution (e.g., "America/New_York", "Europe/London")',
-      placeholder: 'UTC'
-    },
-    validate: (value: any) => {
-      if (value) {
-        try {
-          new Intl.DateTimeFormat('en', { timeZone: value as string })
-          return true
-        } catch {
-          return `Invalid timezone: ${value}. Please use a valid IANA timezone identifier`
-        }
-      }
-      return true
-    }
-  }
-}
-
-export const eventParameters: Record<string, any> = {
-  eventTypes: {
-    type: 'select',
-    hasMany: true,
-    options: [
-      { label: 'User Created', value: 'user.created' },
-      { label: 'User Updated', value: 'user.updated' },
-      { label: 'Document Published', value: 'document.published' },
-      { label: 'Payment Completed', value: 'payment.completed' }
-    ],
-    admin: {
-      description: 'Event types that should trigger this workflow'
-    }
-  },
-  filters: {
-    type: 'json',
-    admin: {
-      description: 'JSON filters to apply to event data (e.g., {"status": "active"})'
-    }
-  }
-}
 
 /**
  * Preset trigger builders for common patterns
@@ -91,28 +8,109 @@ export const eventParameters: Record<string, any> = {
 /**
  * Create a webhook trigger with common webhook parameters pre-configured
  */
-export function webhookTrigger<TSlug extends string>(slug: TSlug) {
+export function webhookTrigger(slug: string): CustomTriggerConfig {
-  return createAdvancedTrigger(slug).extend(webhookParameters)
+  return createTrigger(slug, [
+    {
+      name: 'path',
+      type: 'text',
+      required: true,
+      admin: {
+        description: 'URL path for the webhook endpoint (e.g., "my-webhook")'
+      },
+      validate: (value: any) => {
+        if (typeof value === 'string' && value.includes(' ')) {
+          return 'Webhook path cannot contain spaces'
+        }
+        return true
+      }
+    },
+    {
+      name: 'secret',
+      type: 'text',
+      admin: {
+        description: 'Secret key for webhook signature validation (optional but recommended)'
+      }
+    },
+    {
+      name: 'headers',
+      type: 'json',
+      admin: {
+        description: 'Expected HTTP headers for validation (JSON object)'
+      }
+    }
+  ])
 }
 
 /**
  * Create a scheduled/cron trigger with timing parameters pre-configured
  */
-export function cronTrigger<TSlug extends string>(slug: TSlug) {
+export function cronTrigger(slug: string): CustomTriggerConfig {
-  return createAdvancedTrigger(slug).extend(cronParameters)
+  return createTrigger(slug, [
+    {
+      name: 'expression',
+      type: 'text',
+      required: true,
+      admin: {
+        description: 'Cron expression for scheduling (e.g., "0 9 * * 1" for every Monday at 9 AM)',
+        placeholder: '0 9 * * 1'
+      }
+    },
+    {
+      name: 'timezone',
+      type: 'text',
+      defaultValue: 'UTC',
+      admin: {
+        description: 'Timezone for cron execution (e.g., "America/New_York", "Europe/London")',
+        placeholder: 'UTC'
+      },
+      validate: (value: any) => {
+        if (value) {
+          try {
+            new Intl.DateTimeFormat('en', { timeZone: value as string })
+            return true
+          } catch {
+            return `Invalid timezone: ${value}. Please use a valid IANA timezone identifier`
+          }
+        }
+        return true
+      }
+    }
+  ])
 }
 
 /**
  * Create an event-driven trigger with event filtering parameters
  */
-export function eventTrigger<TSlug extends string>(slug: TSlug) {
+export function eventTrigger(slug: string): CustomTriggerConfig {
-  return createAdvancedTrigger(slug).extend(eventParameters)
+  return createTrigger(slug, [
+    {
+      name: 'eventTypes',
+      type: 'select',
+      hasMany: true,
+      options: [
+        { label: 'User Created', value: 'user.created' },
+        { label: 'User Updated', value: 'user.updated' },
+        { label: 'Document Published', value: 'document.published' },
+        { label: 'Payment Completed', value: 'payment.completed' }
+      ],
+      admin: {
+        description: 'Event types that should trigger this workflow'
+      }
+    },
+    {
+      name: 'filters',
+      type: 'json',
+      admin: {
+        description: 'JSON filters to apply to event data (e.g., {"status": "active"})'
+      }
+    }
+  ])
 }
 
 /**
  * Create a simple manual trigger (no parameters needed)
  */
-export function manualTrigger<TSlug extends string>(slug: TSlug) {
+export function manualTrigger(slug: string): CustomTriggerConfig {
   return {
     slug,
     inputs: []
@@ -122,16 +120,18 @@ export function manualTrigger<TSlug extends string>(slug: TSlug) {
 /**
  * Create an API trigger for external systems to call
  */
-export function apiTrigger<TSlug extends string>(slug: TSlug) {
+export function apiTrigger(slug: string): CustomTriggerConfig {
-  return createAdvancedTrigger(slug).extend({
+  return createTrigger(slug, [
-    endpoint: {
+    {
+      name: 'endpoint',
       type: 'text',
       required: true,
       admin: {
         description: 'API endpoint path (e.g., "/api/triggers/my-trigger")'
       }
     },
-    method: {
+    {
+      name: 'method',
       type: 'select',
       options: ['GET', 'POST', 'PUT', 'PATCH'],
       defaultValue: 'POST',
@@ -139,7 +139,8 @@ export function apiTrigger<TSlug extends string>(slug: TSlug) {
         description: 'HTTP method for the API endpoint'
       }
     },
-    authentication: {
+    {
+      name: 'authentication',
       type: 'select',
       options: [
         { label: 'None', value: 'none' },
@@ -152,5 +153,5 @@ export function apiTrigger<TSlug extends string>(slug: TSlug) {
         description: 'Authentication method for the API endpoint'
       }
     }
-  })
+  ])
 }