0.0.29

- Fix TypeScript types in trigger-helpers with proper interfaces
- Remove all ESLint no-explicit-any warnings with better typing
- Fix component import paths from @/components/* to relative paths
- Regenerate import map with correct component references
- All compilation and linting errors resolved

dev/app/(payload)/admin/importMap.js

@@ -1,5 +1,9 @@
-
+import { default as default_4845c503d8eeb95a2cf39d519276b9b7 } from '../../../../../components/WorkflowExecutionStatus'
+import { default as default_28774f13376b69227276b43eee64e5a1 } from '../../../../../components/StatusCell'
+import { default as default_623fcff70b12e3e87839f97bf237499a } from '../../../../../components/ErrorDisplay'
 
 export const importMap = {
-
+  "../components/WorkflowExecutionStatus#default": default_4845c503d8eeb95a2cf39d519276b9b7,
+  "../components/StatusCell#default": default_28774f13376b69227276b43eee64e5a1,
+  "../components/ErrorDisplay#default": default_623fcff70b12e3e87839f97bf237499a
 }

dev/payload-types.ts

@@ -92,7 +92,7 @@ export interface Config {
     'payload-migrations': PayloadMigrationsSelect<false> | PayloadMigrationsSelect<true>;
   };
   db: {
-    defaultIDType: number;
+    defaultIDType: string;
   };
   globals: {};
   globalsSelect: {};
@@ -136,7 +136,7 @@ export interface UserAuthOperations {
  * via the `definition` "posts".
  */
 export interface Post {
-  id: number;
+  id: string;
   content?: string | null;
   updatedAt: string;
   createdAt: string;
@@ -146,7 +146,7 @@ export interface Post {
  * via the `definition` "media".
  */
 export interface Media {
-  id: number;
+  id: string;
   updatedAt: string;
   createdAt: string;
   url?: string | null;
@@ -164,9 +164,9 @@ export interface Media {
  * via the `definition` "auditLog".
  */
 export interface AuditLog {
-  id: number;
+  id: string;
-  post?: (number | null) | Post;
+  post?: (string | null) | Post;
-  user?: (number | null) | User;
+  user?: (string | null) | User;
   message?: string | null;
   updatedAt: string;
   createdAt: string;
@@ -176,7 +176,7 @@ export interface AuditLog {
  * via the `definition` "users".
  */
 export interface User {
-  id: number;
+  id: string;
   updatedAt: string;
   createdAt: string;
   email: string;
@@ -202,7 +202,7 @@ export interface User {
  * via the `definition` "workflows".
  */
 export interface Workflow {
-  id: number;
+  id: string;
   /**
    * Human-readable name for the workflow
    */
@@ -214,36 +214,45 @@ export interface Workflow {
   triggers?:
     | {
         type?: ('collection-trigger' | 'webhook-trigger' | 'global-trigger' | 'cron-trigger') | null;
+        parameters?:
+          | {
+              [k: string]: unknown;
+            }
+          | unknown[]
+          | string
+          | number
+          | boolean
+          | null;
         /**
          * Collection that triggers the workflow
          */
-        collectionSlug?: ('posts' | 'media') | null;
+        __builtin_collectionSlug?: ('posts' | 'media') | null;
         /**
          * Collection operation that triggers the workflow
          */
-        operation?: ('create' | 'delete' | 'read' | 'update') | null;
+        __builtin_operation?: ('create' | 'delete' | 'read' | 'update') | null;
         /**
-         * URL path for the webhook (e.g., "my-webhook"). Full URL will be /api/workflows/webhook/my-webhook
+         * URL path for the webhook (e.g., "my-webhook"). Full URL will be /api/workflows-webhook/my-webhook
          */
-        webhookPath?: string | null;
+        __builtin_webhookPath?: string | null;
         /**
          * Global that triggers the workflow
          */
-        global?: string | null;
+        __builtin_global?: string | null;
         /**
          * Global operation that triggers the workflow
          */
-        globalOperation?: 'update' | null;
+        __builtin_globalOperation?: 'update' | null;
         /**
          * Cron expression for scheduled execution (e.g., "0 0 * * *" for daily at midnight)
          */
-        cronExpression?: string | null;
+        __builtin_cronExpression?: string | null;
         /**
          * Timezone for cron execution (e.g., "America/New_York", "Europe/London"). Defaults to UTC.
          */
-        timezone?: string | null;
+        __builtin_timezone?: string | null;
         /**
-         * JSONPath expression that must evaluate to true for this trigger to execute the workflow (e.g., "$.doc.status == 'published'")
+         * JSONPath expression that must evaluate to true for this trigger to execute the workflow (e.g., "$.trigger.doc.status == 'published'")
          */
         condition?: string | null;
         id?: string | null;
@@ -253,7 +262,18 @@ export interface Workflow {
     | {
         step?: ('http-request-step' | 'create-document') | null;
         name?: string | null;
-        input?:
+        /**
+         * The URL to make the HTTP request to
+         */
+        url?: string | null;
+        /**
+         * HTTP method to use
+         */
+        method?: ('GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH') | null;
+        /**
+         * HTTP headers as JSON object (e.g., {"Content-Type": "application/json"})
+         */
+        headers?:
           | {
               [k: string]: unknown;
             }
@@ -262,6 +282,80 @@ export interface Workflow {
           | number
           | boolean
           | null;
+        /**
+         * Request body data. Use JSONPath to reference values (e.g., {"postId": "$.trigger.doc.id", "title": "$.trigger.doc.title"})
+         */
+        body?:
+          | {
+              [k: string]: unknown;
+            }
+          | unknown[]
+          | string
+          | number
+          | boolean
+          | null;
+        /**
+         * Request timeout in milliseconds (default: 30000)
+         */
+        timeout?: number | null;
+        authentication?: {
+          /**
+           * Authentication method
+           */
+          type?: ('none' | 'bearer' | 'basic' | 'apikey') | null;
+          /**
+           * Bearer token value
+           */
+          token?: string | null;
+          /**
+           * Basic auth username
+           */
+          username?: string | null;
+          /**
+           * Basic auth password
+           */
+          password?: string | null;
+          /**
+           * API key header name (e.g., "X-API-Key")
+           */
+          headerName?: string | null;
+          /**
+           * API key value
+           */
+          headerValue?: string | null;
+        };
+        /**
+         * Number of retry attempts on failure (max: 5)
+         */
+        retries?: number | null;
+        /**
+         * Delay between retries in milliseconds
+         */
+        retryDelay?: number | null;
+        /**
+         * The collection slug to create a document in
+         */
+        collectionSlug?: string | null;
+        /**
+         * The document data to create. Use JSONPath to reference trigger data (e.g., {"title": "$.trigger.doc.title", "author": "$.trigger.doc.author"})
+         */
+        data?:
+          | {
+              [k: string]: unknown;
+            }
+          | unknown[]
+          | string
+          | number
+          | boolean
+          | null;
+        /**
+         * Create as draft (if collection has drafts enabled)
+         */
+        draft?: boolean | null;
+        /**
+         * Locale for the document (if localization is enabled)
+         */
+        locale?: string | null;
         /**
          * Step names that must complete before this step can run
          */
@@ -282,11 +376,11 @@ export interface Workflow {
  * via the `definition` "workflow-runs".
  */
 export interface WorkflowRun {
-  id: number;
+  id: string;
   /**
    * Reference to the workflow that was executed
    */
-  workflow: number | Workflow;
+  workflow: string | Workflow;
   /**
    * Version of the workflow that was executed
    */
@@ -380,7 +474,7 @@ export interface WorkflowRun {
  * via the `definition` "payload-jobs".
  */
 export interface PayloadJob {
-  id: number;
+  id: string;
   /**
    * Input data provided to the job
    */
@@ -472,40 +566,40 @@ export interface PayloadJob {
  * via the `definition` "payload-locked-documents".
  */
 export interface PayloadLockedDocument {
-  id: number;
+  id: string;
   document?:
     | ({
         relationTo: 'posts';
-        value: number | Post;
+        value: string | Post;
       } | null)
     | ({
         relationTo: 'media';
-        value: number | Media;
+        value: string | Media;
       } | null)
     | ({
         relationTo: 'auditLog';
-        value: number | AuditLog;
+        value: string | AuditLog;
       } | null)
     | ({
         relationTo: 'workflows';
-        value: number | Workflow;
+        value: string | Workflow;
       } | null)
     | ({
         relationTo: 'workflow-runs';
-        value: number | WorkflowRun;
+        value: string | WorkflowRun;
       } | null)
     | ({
         relationTo: 'users';
-        value: number | User;
+        value: string | User;
       } | null)
     | ({
         relationTo: 'payload-jobs';
-        value: number | PayloadJob;
+        value: string | PayloadJob;
       } | null);
   globalSlug?: string | null;
   user: {
     relationTo: 'users';
-    value: number | User;
+    value: string | User;
   };
   updatedAt: string;
   createdAt: string;
@@ -515,10 +609,10 @@ export interface PayloadLockedDocument {
  * via the `definition` "payload-preferences".
  */
 export interface PayloadPreference {
-  id: number;
+  id: string;
   user: {
     relationTo: 'users';
-    value: number | User;
+    value: string | User;
   };
   key?: string | null;
   value?:
@@ -538,7 +632,7 @@ export interface PayloadPreference {
  * via the `definition` "payload-migrations".
  */
 export interface PayloadMigration {
-  id: number;
+  id: string;
   name?: string | null;
   batch?: number | null;
   updatedAt: string;
@@ -592,13 +686,14 @@ export interface WorkflowsSelect<T extends boolean = true> {
     | T
     | {
         type?: T;
-        collectionSlug?: T;
+        parameters?: T;
-        operation?: T;
+        __builtin_collectionSlug?: T;
-        webhookPath?: T;
+        __builtin_operation?: T;
-        global?: T;
+        __builtin_webhookPath?: T;
-        globalOperation?: T;
+        __builtin_global?: T;
-        cronExpression?: T;
+        __builtin_globalOperation?: T;
-        timezone?: T;
+        __builtin_cronExpression?: T;
+        __builtin_timezone?: T;
         condition?: T;
         id?: T;
       };
@@ -607,7 +702,27 @@ export interface WorkflowsSelect<T extends boolean = true> {
     | {
         step?: T;
         name?: T;
-        input?: T;
+        url?: T;
+        method?: T;
+        headers?: T;
+        body?: T;
+        timeout?: T;
+        authentication?:
+          | T
+          | {
+              type?: T;
+              token?: T;
+              username?: T;
+              password?: T;
+              headerName?: T;
+              headerValue?: T;
+            };
+        retries?: T;
+        retryDelay?: T;
+        collectionSlug?: T;
+        data?: T;
+        draft?: T;
+        locale?: T;
         dependencies?: T;
         condition?: T;
         id?: T;
@@ -736,10 +851,118 @@ export interface TaskWorkflowCronExecutor {
  */
 export interface TaskHttpRequestStep {
   input: {
-    url?: string | null;
+    /**
+     * The URL to make the HTTP request to
+     */
+    url: string;
+    /**
+     * HTTP method to use
+     */
+    method?: ('GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH') | null;
+    /**
+     * HTTP headers as JSON object (e.g., {"Content-Type": "application/json"})
+     */
+    headers?:
+      | {
+          [k: string]: unknown;
+        }
+      | unknown[]
+      | string
+      | number
+      | boolean
+      | null;
+    /**
+     * Request body data. Use JSONPath to reference values (e.g., {"postId": "$.trigger.doc.id", "title": "$.trigger.doc.title"})
+     */
+    body?:
+      | {
+          [k: string]: unknown;
+        }
+      | unknown[]
+      | string
+      | number
+      | boolean
+      | null;
+    /**
+     * Request timeout in milliseconds (default: 30000)
+     */
+    timeout?: number | null;
+    authentication?: {
+      /**
+       * Authentication method
+       */
+      type?: ('none' | 'bearer' | 'basic' | 'apikey') | null;
+      /**
+       * Bearer token value
+       */
+      token?: string | null;
+      /**
+       * Basic auth username
+       */
+      username?: string | null;
+      /**
+       * Basic auth password
+       */
+      password?: string | null;
+      /**
+       * API key header name (e.g., "X-API-Key")
+       */
+      headerName?: string | null;
+      /**
+       * API key value
+       */
+      headerValue?: string | null;
+    };
+    /**
+     * Number of retry attempts on failure (max: 5)
+     */
+    retries?: number | null;
+    /**
+     * Delay between retries in milliseconds
+     */
+    retryDelay?: number | null;
   };
   output: {
-    response?: string | null;
+    /**
+     * HTTP status code
+     */
+    status?: number | null;
+    /**
+     * HTTP status text
+     */
+    statusText?: string | null;
+    /**
+     * Response headers
+     */
+    headers?:
+      | {
+          [k: string]: unknown;
+        }
+      | unknown[]
+      | string
+      | number
+      | boolean
+      | null;
+    /**
+     * Response body
+     */
+    body?: string | null;
+    /**
+     * Parsed response data (if JSON)
+     */
+    data?:
+      | {
+          [k: string]: unknown;
+        }
+      | unknown[]
+      | string
+      | number
+      | boolean
+      | null;
+    /**
+     * Request duration in milliseconds
+     */
+    duration?: number | null;
   };
 }
 /**
@@ -753,7 +976,7 @@ export interface TaskCreateDocument {
      */
     collectionSlug: string;
     /**
-     * The document data to create
+     * The document data to create. Use JSONPath to reference trigger data (e.g., {"title": "$.trigger.doc.title", "author": "$.trigger.doc.author"})
      */
     data:
       | {

package-lock.json

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/payload-automation",
-  "version": "0.0.26",
+  "version": "0.0.29",
   "description": "PayloadCMS Automation Plugin - Comprehensive workflow automation system with visual workflow building, execution tracking, and step types",
   "license": "MIT",
   "type": "module",

src/collections/Workflow.ts

@@ -41,7 +41,7 @@ export const createWorkflowCollection: <T extends string>(options: WorkflowsPlug
       type: 'ui',
       admin: {
         components: {
-          Field: '@/components/WorkflowExecutionStatus'
+          Field: '../components/WorkflowExecutionStatus'
         },
         condition: (data) => !!data?.id // Only show for existing workflows
       }
@@ -296,34 +296,9 @@ export const createWorkflowCollection: <T extends string>(options: WorkflowsPlug
           required: false
         },
         // Virtual fields for custom triggers
-        ...(triggers || []).flatMap(t => (t.inputs || []).filter(f => 'name' in f && f.name).map(f => ({
+        // Note: Custom trigger fields from trigger-helpers already have unique names
-          ...f,
+        // We just need to pass them through without modification
-          // Prefix field name with trigger slug to avoid conflicts
+        ...(triggers || []).flatMap(t => (t.inputs || []))
-          name: `__${t.slug}_${(f as any).name}`,
-          admin: {
-            ...(f.admin || {}),
-            condition: (...args) => args[1]?.type === t.slug && (
-              f.admin?.condition ?
-                f.admin.condition.call(this, ...args) :
-                true
-            ),
-          },
-          hooks: {
-            afterRead: [
-              ({ siblingData }) => {
-                return siblingData?.parameters?.[(f as any).name] || undefined
-              }
-            ],
-            beforeChange: [
-              ({ siblingData, value }) => {
-                if (!siblingData.parameters) {siblingData.parameters = {}}
-                siblingData.parameters[(f as any).name] = value
-                return undefined // Virtual field, don't store directly
-              }
-            ]
-          },
-          virtual: true,
-        } as Field)))
       ]
     },
     {

src/collections/WorkflowRuns.ts

@@ -40,7 +40,7 @@ export const WorkflowRunsCollection: CollectionConfig = {
       admin: {
         description: 'Current execution status',
         components: {
-          Cell: '@/components/StatusCell'
+          Cell: '../components/StatusCell'
         }
       },
       defaultValue: 'pending',
@@ -141,7 +141,7 @@ export const WorkflowRunsCollection: CollectionConfig = {
         description: 'Error message if workflow execution failed',
         condition: (_, siblingData) => siblingData?.status === 'failed',
         components: {
-          Field: '@/components/ErrorDisplay'
+          Field: '../components/ErrorDisplay'
         }
       },
     },

src/components/ErrorDisplay.tsx

@@ -166,14 +166,15 @@ export const ErrorDisplay: React.FC<ErrorDisplayProps> = ({
 
       {/* Technical Details Toggle */}
       <div>
-        <Button
+        <div style={{ marginBottom: expanded ? '12px' : '0' }}>
-          onClick={() => setExpanded(!expanded)}
+          <Button
-          size="small"
+            onClick={() => setExpanded(!expanded)}
-          buttonStyle="secondary"
+            size="small"
-          style={{ marginBottom: expanded ? '12px' : '0' }}
+            buttonStyle="secondary"
-        >
+          >
-          {expanded ? 'Hide' : 'Show'} Technical Details
+            {expanded ? 'Hide' : 'Show'} Technical Details
-        </Button>
+          </Button>
+        </div>
         
         {expanded && (
           <div style={{

src/exports/client.ts

@@ -3,7 +3,7 @@
 
 export { TriggerWorkflowButton } from '../components/TriggerWorkflowButton.js'
 export { StatusCell } from '../components/StatusCell.js'
-// export { ErrorDisplay } from '../components/ErrorDisplay.js' // Temporarily disabled
+export { ErrorDisplay } from '../components/ErrorDisplay.js'
 export { WorkflowExecutionStatus } from '../components/WorkflowExecutionStatus.js'
 
 // Future client components can be added here:

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
@@ -37,11 +35,4 @@ export {
   eventTrigger,
   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

@@ -1,138 +1,158 @@
 import type { Field } from 'payload'
+
 import type { CustomTriggerConfig } from '../plugin/config-types.js'
 
+// Types for better type safety
+interface FieldWithName {
+  name: string
+  [key: string]: unknown
+}
+
+interface HookContext {
+  siblingData: Record<string, unknown>
+  value?: unknown
+}
+
+interface ValidationContext {
+  siblingData: Record<string, unknown>
+}
+
 /**
- * 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: FieldWithName, 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}`
+  const uniqueFieldName = `__trigger_${triggerSlug}_${originalName}`
   
-  return {
+  const resultField: Record<string, unknown> = {
-    ...fieldConfig,
+    ...field,
-    name: uniqueFieldName,
-    virtual: true,
     admin: {
-      ...fieldConfig.admin,
+      ...(field.admin as Record<string, unknown> || {}),
-      condition: (_, siblingData) => siblingData?.type === triggerSlug && (
+      condition: (data: unknown, siblingData: Record<string, unknown>) => {
-        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
+        const originalCondition = (field.admin as Record<string, unknown>)?.condition
+        if (originalCondition && typeof originalCondition === 'function') {
+          return triggerMatches && (originalCondition as (data: unknown, siblingData: Record<string, unknown>) => boolean)(data, siblingData)
+        }
+        
+        return triggerMatches
+      }
     },
     hooks: {
-      ...fieldConfig.hooks,
+      ...(field.hooks as Record<string, unknown[]> || {}),
       afterRead: [
-        ...(fieldConfig.hooks?.afterRead || []),
+        ...((field.hooks as Record<string, unknown[]>)?.afterRead || []),
-        ({ siblingData }) => siblingData?.parameters?.[name] || fieldConfig.defaultValue
+        ({ siblingData }: HookContext) => {
+          // Read the value from the parameters JSON field
+          const parameters = siblingData?.parameters as Record<string, unknown>
+          return parameters?.[originalName] ?? (field as Record<string, unknown>).defaultValue
+        }
       ],
       beforeChange: [
-        ...(fieldConfig.hooks?.beforeChange || []),
+        ...((field.hooks as Record<string, unknown[]>)?.beforeChange || []),
-        ({ value, siblingData }) => {
+        ({ siblingData, value }: HookContext) => {
-          if (!siblingData.parameters) siblingData.parameters = {}
+          // Store the value in the parameters JSON field
-          siblingData.parameters[name] = value
+          if (!siblingData.parameters) {
+            siblingData.parameters = {}
+          }
+          const parameters = siblingData.parameters as Record<string, unknown>
+          parameters[originalName] = value
           return undefined // Virtual field, don't store directly
         }
       ]
     },
-    validate: fieldConfig.validate || fieldConfig.required ? 
+    name: uniqueFieldName,
-      (value: any, args: any) => {
+    virtual: true,
-        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) {
+  const hasValidation = (field as Record<string, unknown>).validate || (field as Record<string, unknown>).required
-          return `${fieldConfig.admin?.description || name} is required for ${triggerSlug}`
+  if (hasValidation) {
-        }
+    resultField.validate = (value: unknown, args: ValidationContext) => {
-        
+      const parameters = args.siblingData?.parameters as Record<string, unknown>
-        // Run original validation if present
+      const paramValue = value ?? parameters?.[originalName]
-        return fieldConfig.validate?.(paramValue, args) ?? true
+      
-      } : 
+      // Check required validation
-      undefined
+      const isRequired = (field as Record<string, unknown>).required
-  } as Field
+      if (isRequired && args.siblingData?.type === triggerSlug && !paramValue) {
+        const fieldLabel = (field as Record<string, unknown>).label as string
+        const adminDesc = ((field as Record<string, unknown>).admin as Record<string, unknown>)?.description as string
+        const label = fieldLabel || adminDesc || originalName
+        return `${label} is required for ${triggerSlug}`
+      }
+      
+      // Run original validation if present
+      const originalValidate = (field as Record<string, unknown>).validate
+      if (originalValidate && typeof originalValidate === 'function') {
+        return (originalValidate as (value: unknown, args: ValidationContext) => boolean | string)(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: FieldWithName[]): 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'
       }
     }
-  })
+  ])
 }