0.0.36

- Change default log level to 'warn' for production
- Add PAYLOAD_AUTOMATION_LOG_LEVEL environment variable
- Remove all verbose config-phase logs
- Add documentation for log level control

README.md

@@ -155,6 +155,34 @@ Use JSONPath to access workflow data:
 - Node.js ^18.20.2 || >=20.9.0
 - pnpm ^9 || ^10
 
+## Environment Variables
+
+Control plugin logging with these environment variables:
+
+### `PAYLOAD_AUTOMATION_LOG_LEVEL`
+Controls both configuration-time and runtime logging. 
+- **Values**: `silent`, `error`, `warn`, `info`, `debug`, `trace`
+- **Default**: `warn`
+- **Example**: `PAYLOAD_AUTOMATION_LOG_LEVEL=debug`
+
+### `PAYLOAD_AUTOMATION_CONFIG_LOG_LEVEL` (optional)
+Override log level specifically for configuration-time logs (plugin setup).
+- **Values**: Same as above
+- **Default**: Falls back to `PAYLOAD_AUTOMATION_LOG_LEVEL` or `warn`
+- **Example**: `PAYLOAD_AUTOMATION_CONFIG_LOG_LEVEL=silent`
+
+### Production Usage
+For production, keep the default (`warn`) or use `error` or `silent`:
+```bash
+PAYLOAD_AUTOMATION_LOG_LEVEL=error npm start
+```
+
+### Development Usage
+For debugging, use `debug` or `info`:
+```bash
+PAYLOAD_AUTOMATION_LOG_LEVEL=debug npm run dev
+```
+
 ## Documentation
 
 Full documentation coming soon. For now, explore the development environment in the repository for examples and patterns.

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

@@ -1,5 +1,9 @@
-
+import { WorkflowExecutionStatus as WorkflowExecutionStatus_6f365a93b6cb4b34ad564b391e21db6f } from '@xtr-dev/payload-automation/client'
+import { StatusCell as StatusCell_6f365a93b6cb4b34ad564b391e21db6f } from '@xtr-dev/payload-automation/client'
+import { ErrorDisplay as ErrorDisplay_6f365a93b6cb4b34ad564b391e21db6f } from '@xtr-dev/payload-automation/client'
 
 export const importMap = {
-
+  "@xtr-dev/payload-automation/client#WorkflowExecutionStatus": WorkflowExecutionStatus_6f365a93b6cb4b34ad564b391e21db6f,
+  "@xtr-dev/payload-automation/client#StatusCell": StatusCell_6f365a93b6cb4b34ad564b391e21db6f,
+  "@xtr-dev/payload-automation/client#ErrorDisplay": ErrorDisplay_6f365a93b6cb4b34ad564b391e21db6f
 }

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;
-  post?: (number | null) | Post;
-  user?: (number | null) | User;
+  id: string;
+  post?: (string | null) | Post;
+  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;
-        operation?: T;
-        webhookPath?: T;
-        global?: T;
-        globalOperation?: T;
-        cronExpression?: T;
-        timezone?: T;
+        parameters?: T;
+        __builtin_collectionSlug?: T;
+        __builtin_operation?: T;
+        __builtin_webhookPath?: T;
+        __builtin_global?: T;
+        __builtin_globalOperation?: 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.28",
+  "version": "0.0.36",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@xtr-dev/payload-workflows",
-      "version": "0.0.28",
+      "version": "0.0.36",
       "license": "MIT",
       "dependencies": {
         "jsonpath-plus": "^10.3.0",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/payload-automation",
-  "version": "0.0.28",
+  "version": "0.0.36",
   "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: '@xtr-dev/payload-automation/client#WorkflowExecutionStatus'
         },
         condition: (data) => !!data?.id // Only show for existing workflows
       }
@@ -319,17 +319,45 @@ export const createWorkflowCollection: <T extends string>(options: WorkflowsPlug
             }
           ]
         },
-        ...(steps || []).flatMap(step => (step.inputSchema || []).map(field => ({
-          ...field,
-          admin: {
-            ...(field.admin || {}),
-            condition: (...args) => args[1]?.step === step.slug && (
-              field.admin?.condition ?
-                field.admin.condition.call(this, ...args) :
-                true
-            ),
-          },
-        } as Field))),
+        ...(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,
+          };
+
+          // Add hooks to store/retrieve from the step's input data
+          resultField.hooks = {
+            ...((field as any).hooks || {}),
+            afterRead: [
+              ...(((field as any).hooks)?.afterRead || []),
+              ({ siblingData }: any) => {
+                // 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',

src/collections/WorkflowRuns.ts

@@ -40,7 +40,7 @@ export const WorkflowRunsCollection: CollectionConfig = {
       admin: {
         description: 'Current execution status',
         components: {
-          Cell: '@/components/StatusCell'
+          Cell: '@xtr-dev/payload-automation/client#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: '@xtr-dev/payload-automation/client#ErrorDisplay'
         }
       },
     },

src/components/ErrorDisplay.tsx

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

src/core/workflow-executor.ts

@@ -990,12 +990,6 @@ export class WorkflowExecutor {
     previousDoc: unknown,
     req: PayloadRequest
   ): Promise<void> {
-    console.log('🚨 EXECUTOR: executeTriggeredWorkflows called!')
-    console.log('🚨 EXECUTOR: Collection =', collection)
-    console.log('🚨 EXECUTOR: Operation =', operation)
-    console.log('🚨 EXECUTOR: Doc ID =', (doc as any)?.id)
-    console.log('🚨 EXECUTOR: Has payload?', !!this.payload)
-    console.log('🚨 EXECUTOR: Has logger?', !!this.logger)
     
     this.logger.info({
       collection,
@@ -1032,13 +1026,7 @@ export class WorkflowExecutor {
         this.logger.debug({
           workflowId: workflow.id,
           workflowName: workflow.name,
-          triggerCount: triggers?.length || 0,
-          triggers: triggers?.map(t => ({
-            type: t.type,
-            collection: t.parameters?.collection,
-            collectionSlug: t.parameters?.collectionSlug,
-            operation: t.parameters?.operation
-          }))
+          triggerCount: triggers?.length || 0
         }, 'Checking workflow triggers')
 
         const matchingTriggers = triggers?.filter(trigger =>
@@ -1087,12 +1075,9 @@ export class WorkflowExecutor {
               collection,
               operation,
               condition: trigger.condition,
-              docId: (doc as any)?.id,
-              docFields: doc ? Object.keys(doc) : [],
-              previousDocId: (previousDoc as any)?.id,
               workflowId: workflow.id,
               workflowName: workflow.name
-            }, 'Evaluating collection trigger condition')
+            }, 'Evaluating trigger condition')
 
             const conditionMet = this.evaluateCondition(trigger.condition, context)
 

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/plugin/index.ts

@@ -145,7 +145,6 @@ export const workflowsPlugin =
       // CRITICAL: Modify existing collection configs BEFORE PayloadCMS processes them
       // This is the ONLY time we can add hooks that will actually work
       const logger = getConfigLogger()
-      logger.info('Attempting to modify collection configs before PayloadCMS initialization...')
 
       if (config.collections && pluginOptions.collectionTriggers) {
         for (const [triggerSlug, triggerConfig] of Object.entries(pluginOptions.collectionTriggers)) {
@@ -159,7 +158,6 @@ export const workflowsPlugin =
           }
 
           const collection = config.collections[collectionIndex]
-          logger.info(`Found collection '${triggerSlug}' - modifying its hooks...`)
 
           // Initialize hooks if needed
           if (!collection.hooks) {
@@ -186,19 +184,40 @@ export const workflowsPlugin =
                 }, 'Collection automation hook triggered')
 
                 if (!registry.isInitialized) {
-                  logger.warn('Workflow executor not yet initialized, skipping execution')
-                  return undefined
+                  logger.warn('Workflow executor not yet initialized, attempting lazy initialization')
+                  
+                  try {
+                    // Try to create executor if we have a payload instance
+                    if (args.req?.payload) {
+                      logger.info('Creating workflow executor via lazy initialization')
+                      const { WorkflowExecutor } = await import('../core/workflow-executor.js')
+                      const executor = new WorkflowExecutor(args.req.payload, logger)
+                      setWorkflowExecutor(executor, logger)
+                      logger.info('Lazy initialization successful')
+                    } else {
+                      logger.error('Cannot lazy initialize - no payload instance available')
+                      await createFailedWorkflowRun(args, 'Workflow executor not initialized and lazy initialization failed - no payload instance', logger)
+                      return undefined
+                    }
+                  } catch (error) {
+                    logger.error('Lazy initialization failed:', error)
+                    const errorMessage = error instanceof Error ? error.message : String(error)
+                    await createFailedWorkflowRun(args, `Workflow executor lazy initialization failed: ${errorMessage}`, logger)
+                    return undefined
+                  }
                 }
 
-                if (!registry.executor) {
+                // Re-check registry after potential lazy initialization
+                const updatedRegistry = getExecutorRegistry()
+                if (!updatedRegistry.executor) {
                   logger.error('Workflow executor is null despite being marked as initialized')
                   // Create a failed workflow run to track this issue
-                  await createFailedWorkflowRun(args, 'Executor not available', logger)
+                  await createFailedWorkflowRun(args, 'Executor not available after initialization', logger)
                   return undefined
                 }
 
                 logger.debug('Executing triggered workflows...')
-                await registry.executor.executeTriggeredWorkflows(
+                await updatedRegistry.executor.executeTriggeredWorkflows(
                   args.collection.slug,
                   args.operation,
                   args.doc,
@@ -245,7 +264,6 @@ export const workflowsPlugin =
 
           // Add the hook to the collection config
           collection.hooks.afterChange.push(automationHook)
-          logger.info(`Added automation hook to '${triggerSlug}' - hook count: ${collection.hooks.afterChange.length}`)
         }
       }
 
@@ -254,17 +272,13 @@ export const workflowsPlugin =
       }
 
       const configLogger = getConfigLogger()
-      configLogger.info(`Configuring workflow plugin with ${Object.keys(pluginOptions.collectionTriggers || {}).length} collection triggers`)
 
       // Generate cron tasks for workflows with cron triggers
       generateCronTasks(config)
 
       for (const step of pluginOptions.steps) {
         if (!config.jobs?.tasks?.find(task => task.slug === step.slug)) {
-          configLogger.debug(`Registering task: ${step.slug}`)
           config.jobs?.tasks?.push(step)
-        } else {
-          configLogger.debug(`Task ${step.slug} already registered, skipping`)
         }
       }
 
@@ -274,11 +288,9 @@ export const workflowsPlugin =
       // Set up onInit to register collection hooks and initialize features
       const incomingOnInit = config.onInit
       config.onInit = async (payload) => {
-        configLogger.info(`onInit called - collections: ${Object.keys(payload.collections).length}`)
 
         // Execute any existing onInit functions first
         if (incomingOnInit) {
-          configLogger.debug('Executing existing onInit function')
           await incomingOnInit(payload)
         }
 
@@ -290,10 +302,8 @@ export const workflowsPlugin =
         logger.info(`Plugin configuration: ${Object.keys(pluginOptions.collectionTriggers || {}).length} collection triggers, ${pluginOptions.steps?.length || 0} steps`)
 
         // Create workflow executor instance
-        console.log('🚨 CREATING WORKFLOW EXECUTOR INSTANCE')
+        logger.debug('Creating workflow executor instance')
         const executor = new WorkflowExecutor(payload, logger)
-        console.log('🚨 EXECUTOR CREATED:', typeof executor)
-        console.log('🚨 EXECUTOR METHODS:', Object.getOwnPropertyNames(Object.getPrototypeOf(executor)))
 
         // Register executor with proper dependency injection
         setWorkflowExecutor(executor, logger)

src/plugin/init-collection-hooks.ts

@@ -40,13 +40,6 @@ export function initCollectionHooks<T extends string>(pluginOptions: WorkflowsPl
       collection.config.hooks.afterChange.push(async (change) => {
         const operation = change.operation as 'create' | 'update'
         
-        // AGGRESSIVE LOGGING - this should ALWAYS appear
-        console.log('🚨 AUTOMATION PLUGIN HOOK CALLED! 🚨')
-        console.log('Collection:', change.collection.slug)
-        console.log('Operation:', operation)
-        console.log('Doc ID:', change.doc?.id)
-        console.log('Has executor?', !!executor)
-        console.log('Executor type:', typeof executor)
         
         logger.info({
           slug: change.collection.slug,
@@ -55,10 +48,9 @@ export function initCollectionHooks<T extends string>(pluginOptions: WorkflowsPl
           previousDocId: change.previousDoc?.id,
           hasExecutor: !!executor,
           executorType: typeof executor
-        }, 'AUTOMATION PLUGIN: Collection hook triggered')
+        }, 'Collection automation hook triggered')
 
         try {
-          console.log('🚨 About to call executeTriggeredWorkflows')
           
           // Execute workflows for this trigger
           await executor.executeTriggeredWorkflows(
@@ -69,15 +61,13 @@ export function initCollectionHooks<T extends string>(pluginOptions: WorkflowsPl
             change.req
           )
           
-          console.log('🚨 executeTriggeredWorkflows completed without error')
           
           logger.info({
             slug: change.collection.slug,
             operation,
             docId: change.doc?.id
-          }, 'AUTOMATION PLUGIN: executeTriggeredWorkflows completed successfully')
+          }, 'Workflow execution completed successfully')
         } catch (error) {
-          console.log('🚨 AUTOMATION PLUGIN ERROR:', error)
           
           logger.error({
             slug: change.collection.slug,

src/plugin/init-webhook.ts

@@ -7,8 +7,6 @@ export function initWebhookEndpoint(config: Config, webhookPrefix = 'webhook'):
   const logger = getConfigLogger()
   // Ensure the prefix starts with a slash
   const normalizedPrefix = webhookPrefix.startsWith('/') ? webhookPrefix : `/${webhookPrefix}`
-  logger.debug(`Adding webhook endpoint to config with prefix: ${normalizedPrefix}`)
-  logger.debug('Current config.endpoints length:', config.endpoints?.length || 0)
 
   // Define webhook endpoint
   const webhookEndpoint = {
@@ -171,9 +169,5 @@ export function initWebhookEndpoint(config: Config, webhookPrefix = 'webhook'):
   if (!existingEndpoint) {
     // Combine existing endpoints with the webhook endpoint
     config.endpoints = [...(config.endpoints || []), webhookEndpoint]
-    logger.debug(`Webhook endpoint added at path: ${webhookEndpoint.path}`)
-    logger.debug('New config.endpoints length:', config.endpoints.length)
-  } else {
-    logger.debug(`Webhook endpoint already exists at path: ${webhookEndpoint.path}`)
   }
 }

src/plugin/logger.ts

@@ -3,25 +3,40 @@ import type { Payload } from 'payload'
 // Global logger instance - use Payload's logger type
 let pluginLogger: null | Payload['logger'] = null
 
+/**
+ * Get the configured log level from environment variables
+ * Supports: PAYLOAD_AUTOMATION_LOG_LEVEL for unified control
+ * Or separate: PAYLOAD_AUTOMATION_CONFIG_LOG_LEVEL and PAYLOAD_AUTOMATION_LOG_LEVEL
+ */
+function getConfigLogLevel(): string {
+  return process.env.PAYLOAD_AUTOMATION_CONFIG_LOG_LEVEL || 
+         process.env.PAYLOAD_AUTOMATION_LOG_LEVEL || 
+         'warn' // Default to warn level for production
+}
+
 /**
  * Simple config-time logger for use during plugin configuration
  * Uses console with plugin prefix since Payload logger isn't available yet
  */
 const configLogger = {
   debug: <T>(message: string, ...args: T[]) => {
-    if (!process.env.PAYLOAD_AUTOMATION_CONFIG_LOGGING) {return}
-    console.log(`[payload-automation] ${message}`, ...args)
+    const level = getConfigLogLevel()
+    if (level === 'silent' || (level !== 'debug' && level !== 'trace')) {return}
+    console.debug(`[payload-automation] ${message}`, ...args)
   },
   error: <T>(message: string, ...args: T[]) => {
-    if (!process.env.PAYLOAD_AUTOMATION_CONFIG_LOGGING) {return}
+    const level = getConfigLogLevel()
+    if (level === 'silent') {return}
     console.error(`[payload-automation] ${message}`, ...args)
   },
   info: <T>(message: string, ...args: T[]) => {
-    if (!process.env.PAYLOAD_AUTOMATION_CONFIG_LOGGING) {return}
-    console.log(`[payload-automation] ${message}`, ...args)
+    const level = getConfigLogLevel()
+    if (level === 'silent' || level === 'error' || level === 'warn') {return}
+    console.info(`[payload-automation] ${message}`, ...args)
   },
   warn: <T>(message: string, ...args: T[]) => {
-    if (!process.env.PAYLOAD_AUTOMATION_CONFIG_LOGGING) {return}
+    const level = getConfigLogLevel()
+    if (level === 'silent' || level === 'error') {return}
     console.warn(`[payload-automation] ${message}`, ...args)
   }
 }
@@ -39,8 +54,13 @@ export function getConfigLogger() {
  */
 export function initializeLogger(payload: Payload): Payload['logger'] {
   // Create a child logger with plugin identification
+  // Use PAYLOAD_AUTOMATION_LOG_LEVEL as the primary env var
+  const logLevel = process.env.PAYLOAD_AUTOMATION_LOG_LEVEL || 
+                   process.env.PAYLOAD_AUTOMATION_LOGGING || // Legacy support
+                   'warn' // Default to warn level for production
+  
   pluginLogger = payload.logger.child({
-    level: process.env.PAYLOAD_AUTOMATION_LOGGING || 'silent',
+    level: logLevel,
     plugin: '@xtr-dev/payload-automation'
   })
   return pluginLogger

src/utils/trigger-helpers.ts

@@ -1,6 +1,22 @@
 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>
+}
+
 /**
  * Creates a virtual field for a trigger parameter that stores its value in the parameters JSON field
  * 
@@ -25,7 +41,7 @@ import type { CustomTriggerConfig } from '../plugin/config-types.js'
  * }
  * ```
  */
-export function createTriggerField(field: any, triggerSlug: string): Field {
+export function createTriggerField(field: FieldWithName, triggerSlug: string): Field {
   const originalName = field.name
   if (!originalName) {
     throw new Error('Field must have a name property')
@@ -34,61 +50,70 @@ export function createTriggerField(field: any, triggerSlug: string): Field {
   // Create a unique field name by prefixing with trigger slug
   const uniqueFieldName = `__trigger_${triggerSlug}_${originalName}`
   
-  const resultField: any = {
+  const resultField: Record<string, unknown> = {
     ...field,
-    name: uniqueFieldName,
-    virtual: true,
     admin: {
-      ...(field.admin || {}),
-      condition: (data: any, siblingData: any) => {
+      ...(field.admin as Record<string, unknown> || {}),
+      condition: (data: unknown, siblingData: Record<string, unknown>) => {
         // Only show this field when the trigger type matches
         const triggerMatches = siblingData?.type === triggerSlug
         
         // If the original field had a condition, combine it with our trigger condition
-        if (field.admin?.condition) {
-          return triggerMatches && field.admin.condition(data, siblingData)
+        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: {
-      ...(field.hooks || {}),
+      ...(field.hooks as Record<string, unknown[]> || {}),
       afterRead: [
-        ...(field.hooks?.afterRead || []),
-        ({ siblingData }: any) => {
+        ...((field.hooks as Record<string, unknown[]>)?.afterRead || []),
+        ({ siblingData }: HookContext) => {
           // Read the value from the parameters JSON field
-          return siblingData?.parameters?.[originalName] ?? field.defaultValue
+          const parameters = siblingData?.parameters as Record<string, unknown>
+          return parameters?.[originalName] ?? (field as Record<string, unknown>).defaultValue
         }
       ],
       beforeChange: [
-        ...(field.hooks?.beforeChange || []),
-        ({ value, siblingData }: any) => {
+        ...((field.hooks as Record<string, unknown[]>)?.beforeChange || []),
+        ({ siblingData, value }: HookContext) => {
           // Store the value in the parameters JSON field
           if (!siblingData.parameters) {
             siblingData.parameters = {}
           }
-          siblingData.parameters[originalName] = value
+          const parameters = siblingData.parameters as Record<string, unknown>
+          parameters[originalName] = value
           return undefined // Virtual field, don't store directly
         }
       ]
-    }
+    },
+    name: uniqueFieldName,
+    virtual: true,
   }
 
   // Only add validate if the field supports it (data fields)
-  if (field.validate || field.required) {
-    resultField.validate = (value: any, args: any) => {
-      const paramValue = value ?? args.siblingData?.parameters?.[originalName]
+  const hasValidation = (field as Record<string, unknown>).validate || (field as Record<string, unknown>).required
+  if (hasValidation) {
+    resultField.validate = (value: unknown, args: ValidationContext) => {
+      const parameters = args.siblingData?.parameters as Record<string, unknown>
+      const paramValue = value ?? parameters?.[originalName]
       
       // Check required validation
-      if (field.required && args.siblingData?.type === triggerSlug && !paramValue) {
-        const label = field.label || field.admin?.description || originalName
+      const isRequired = (field as Record<string, unknown>).required
+      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
-      if (field.validate) {
-        return field.validate(paramValue, args)
+      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
@@ -125,7 +150,7 @@ export function createTriggerField(field: any, triggerSlug: string): Field {
  * ])
  * ```
  */
-export function createTrigger(slug: string, fields: Field[]): CustomTriggerConfig {
+export function createTrigger(slug: string, fields: FieldWithName[]): CustomTriggerConfig {
   return {
     slug,
     inputs: fields.map(field => createTriggerField(field, slug))