@open-mercato/core 0.6.6-develop.6460.1.f94c74174c → 0.6.6-develop.6471.1.9ab5bdd79a

package/src/modules/workflows/lib/compensation-handler.ts

@@ -3,6 +3,9 @@ import type { AwilixContainer } from 'awilix'
 import { WorkflowInstance, WorkflowDefinition, WorkflowEvent } from '../data/entities'
 import { executeActivity } from './activity-executor'
 import { logWorkflowEvent } from './event-logger'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
 
 /**
  * Compensation Handler - Implements Saga pattern for workflow rollback
@@ -100,7 +103,7 @@ export async function compensateWorkflow(
     const activityDef = findActivityInDefinition(definition, activityId)
 
     if (!activityDef) {
-      console.warn(`Activity ${activityId} not found in definition, skipping compensation`)
+      logger.warn('Activity not found in definition, skipping compensation', { activityId })
       continue
     }
 
@@ -114,7 +117,7 @@ export async function compensateWorkflow(
     const compensationDef = findActivityInDefinition(definition, compensationActivityId)
 
     if (!compensationDef) {
-      console.warn(`Compensation activity ${compensationActivityId} not found, skipping`)
+      logger.warn('Compensation activity not found, skipping', { compensationActivityId })
       result.failedCompensations.push(activityId)
       continue
     }

package/src/modules/workflows/lib/edgeFormTransforms.ts

@@ -8,6 +8,9 @@
 import type { Edge } from '@xyflow/react'
 import type { Activity } from '../components/fields/ActivityArrayEditor'
 import type { TransitionCondition } from '../components/fields/BusinessRuleConditionsEditor'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
 
 /**
  * Normalized condition format (object only, no string)
@@ -119,7 +122,7 @@ export function formValuesToEdgeUpdates(
       const parsed = JSON.parse(values.advancedConfig)
       Object.assign(updates, parsed)
     } catch (error) {
-      console.error('Invalid JSON in Advanced Configuration:', error)
+      logger.error('Invalid JSON in Advanced Configuration', { err: error })
       throw new Error('Invalid JSON in Advanced Configuration. Please check your syntax.')
     }
   }

package/src/modules/workflows/lib/event-trigger-service.ts

@@ -22,6 +22,9 @@ import {
   type WorkflowDefinitionTrigger,
 } from '../data/entities'
 import { startWorkflow, executeWorkflow } from './workflow-executor'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows').child({ component: 'event-trigger' })
 
 // ============================================================================
 // Types
@@ -602,7 +605,7 @@ export async function processEventTriggers(
       // Check concurrency limit
       const canStart = await checkConcurrencyLimit(em, trigger)
       if (!canStart) {
-        console.log(`[workflow-trigger] Skipping trigger "${trigger.name}": max concurrent instances reached`)
+        logger.debug('Skipping trigger: max concurrent instances reached', { triggerId: trigger.id, triggerName: trigger.name })
         result.skipped++
         continue
       }
@@ -659,12 +662,12 @@ export async function processEventTriggers(
 
       // Execute workflow asynchronously (don't wait)
       executeWorkflow(em.fork(), container, instance.id).catch(err => {
-        console.error(`[workflow-trigger] Error executing workflow ${instance.id}:`, err)
+        logger.error('Error executing workflow', { instanceId: instance.id, err })
       })
 
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error)
-      console.error(`[workflow-trigger] Error processing trigger "${trigger.name}":`, error)
+      logger.error('Error processing trigger', { triggerId: trigger.id, triggerName: trigger.name, err: error })
       result.errors.push({
         triggerId: trigger.id,
         error: errorMessage,

package/src/modules/workflows/lib/nodeFormTransforms.ts

@@ -11,6 +11,9 @@ import type { Activity } from '../components/fields/ActivityArrayEditor'
 import type { Mapping } from '../components/fields/MappingArrayEditor'
 import type { StartPreCondition } from '../components/fields/StartPreConditionsEditor'
 import { sanitizeId } from './graph-utils'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
 
 /**
  * Form values interface matching CrudForm field structure
@@ -343,7 +346,7 @@ export function formValuesToNodeUpdates(
       const parsed = JSON.parse(values.advancedConfig)
       Object.assign(updates, parsed)
     } catch (error) {
-      console.error('Invalid JSON in Advanced Configuration:', error)
+      logger.error('Invalid JSON in Advanced Configuration', { err: error })
       throw new Error('Invalid JSON in Advanced Configuration. Please check your syntax.')
     }
   }

package/src/modules/workflows/lib/seeds.ts

@@ -8,6 +8,9 @@ import {
   invalidateBusinessRuleDiscoveryCache,
   type RuleDiscoveryCache,
 } from '@open-mercato/core/modules/business_rules/lib/rule-engine'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
 
 const __esmDirname = path.dirname(fileURLToPath(import.meta.url))
 
@@ -110,7 +113,14 @@ async function seedWorkflowDefinition(
       (seedHasTransitionPreConditions && !existingHasTransitionPreConditions)
 
     if (needsUpdate) {
-      console.log(`[seed] Updating workflow ${workflowId} (steps: ${existingStepCount}→${seedStepCount}, transitions: ${existingTransitionCount}→${seedTransitionCount})`)
+      logger.info('Updating seeded workflow', {
+        component: 'seed',
+        workflowId,
+        existingStepCount,
+        seedStepCount,
+        existingTransitionCount,
+        seedTransitionCount,
+      })
       existing.definition = seed.definition
       await em.flush()
       return true
@@ -155,7 +165,12 @@ async function seedGuardRules(
       // Check if entityType or eventType needs updating
       const needsUpdate = existing.entityType !== rule.entityType || existing.eventType !== rule.eventType
       if (needsUpdate) {
-        console.log(`[seed] Updating business rule ${ruleId}: entityType=${rule.entityType}, eventType=${rule.eventType}`)
+        logger.info('Updating seeded business rule', {
+          component: 'seed',
+          ruleId,
+          entityType: rule.entityType,
+          eventType: rule.eventType,
+        })
         existing.entityType = rule.entityType
         existing.eventType = rule.eventType ?? null
         updated += 1

package/src/modules/workflows/lib/signal-handler.ts

@@ -13,6 +13,9 @@ import type * as eventLoggerModule from './event-logger'
 import type * as stepHandlerModule from './step-handler'
 import type * as transitionHandlerModule from './transition-handler'
 import type * as workflowExecutorModule from './workflow-executor'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
 
 export interface SendSignalOptions {
   /**
@@ -357,7 +360,7 @@ export async function sendSignalByCorrelationKey(
       signalsProcessed++
     } catch (error) {
       // Log error but continue processing other instances
-      console.error(`Failed to send signal to instance ${instance.id}:`, error)
+      logger.error('Failed to send signal to instance', { instanceId: instance.id, err: error })
     }
   }
 

package/src/modules/workflows/lib/start-validator.ts

@@ -11,6 +11,9 @@ import { WorkflowDefinition } from '../data/entities'
 import * as ruleEngine from '../../business_rules/lib/rule-engine'
 import { findWorkflowDefinition } from './find-definition'
 import type { StartPreCondition } from '../data/validators'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
 
 // ============================================================================
 // Types and Interfaces
@@ -111,12 +114,16 @@ export async function validateWorkflowStart(
 
   const preConditions: StartPreCondition[] = startStep.preConditions || []
 
-  console.log('[start-validator] START step:', JSON.stringify(startStep, null, 2))
-  console.log('[start-validator] preConditions:', preConditions.length, JSON.stringify(preConditions))
+  logger.debug('Evaluating START step pre-conditions', {
+    component: 'start-validator',
+    startStep,
+    preConditionCount: preConditions.length,
+    preConditions,
+  })
 
   // If no pre-conditions, workflow can start
   if (preConditions.length === 0) {
-    console.log('[start-validator] No pre-conditions defined, allowing start')
+    logger.debug('No pre-conditions defined, allowing start', { component: 'start-validator' })
     return {
       canStart: true,
       errors: [],

package/src/modules/workflows/lib/step-handler.ts

@@ -22,6 +22,9 @@ import {
 } from '../data/entities'
 import { parseDuration } from './duration'
 import { logWorkflowEvent } from './event-logger'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
 
 // ============================================================================
 // Types and Interfaces
@@ -281,7 +284,7 @@ export async function executeStep(
       }
     } catch (updateError) {
       // Swallow update errors to preserve original error
-      console.error('Failed to update step instance with error:', updateError)
+      logger.error('Failed to update step instance with error', { err: updateError })
     }
 
     return {

package/src/modules/workflows/lib/task-handler.ts

@@ -22,6 +22,9 @@ import {
 import { executeWorkflow } from './workflow-executor'
 import * as stepHandler from './step-handler'
 import * as transitionHandler from './transition-handler'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
 
 // ============================================================================
 // Types and Interfaces
@@ -244,7 +247,7 @@ export async function completeUserTask(
   )
 
   if (!transitionResult.success) {
-    console.error(`[TaskHandler] Transition failed:`, transitionResult.error)
+    logger.error('Transition failed', { component: 'task-handler', err: transitionResult.error })
     // Don't throw, just leave workflow in current state
     return
   }

package/src/modules/workflows/lib/transition-handler.ts

@@ -35,6 +35,9 @@ import {
   setTokenPendingTransition,
   touchToken,
 } from './execution-token'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
 
 // ============================================================================
 // Types and Interfaces
@@ -291,7 +294,7 @@ export async function findValidTransitions(
 
     return results
   } catch (error) {
-    console.error('Error finding valid transitions:', error)
+    logger.error('Error finding valid transitions', { err: error })
     return []
   }
 }
@@ -844,7 +847,7 @@ async function evaluatePreConditions(
       errors: errors.length > 0 ? errors : undefined,
     }
   } catch (error) {
-    console.error('Error evaluating pre-conditions:', error)
+    logger.error('Error evaluating pre-conditions', { err: error })
     return {
       allowed: false,
       executedRules: [],
@@ -968,7 +971,7 @@ async function evaluatePostConditions(
       errors: errors.length > 0 ? errors : undefined,
     }
   } catch (error) {
-    console.error('Error evaluating post-conditions:', error)
+    logger.error('Error evaluating post-conditions', { err: error })
     return {
       allowed: false,
       executedRules: [],

package/src/modules/workflows/lib/workflow-executor.ts

@@ -20,6 +20,9 @@ import {
 } from '../data/entities'
 import { compensateWorkflow } from './compensation-handler'
 import { findWorkflowDefinition } from './find-definition'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
 
 // ============================================================================
 // Types and Interfaces
@@ -430,7 +433,13 @@ export async function executeWorkflow(
 
           if (!transitionResult.success) {
             const rejectionMessage = transitionResult.error || 'Transition failed'
-            console.error(`[WORKFLOW] Transition rejected (instance: ${currentInstance.id}, workflow: ${currentInstance.workflowId}, step: ${currentInstance.currentStepId} → ${selectedTransition.toStepId}): ${rejectionMessage}`)
+            logger.error('Transition rejected', {
+              instanceId: currentInstance.id,
+              workflowId: currentInstance.workflowId,
+              fromStepId: currentInstance.currentStepId,
+              toStepId: selectedTransition.toStepId,
+              err: rejectionMessage,
+            })
             errors.push(rejectionMessage)
 
             await completeWorkflow(trx, container, instanceId, 'FAILED', {
@@ -496,8 +505,13 @@ export async function executeWorkflow(
           await trx.flush()
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error)
-          console.error(`[WORKFLOW] Transition execution failed (instance: ${currentInstance.id}, workflow: ${currentInstance.workflowId}, step: ${currentInstance.currentStepId} → ${selectedTransition.toStepId}):`, error)
-          console.error('[WORKFLOW] Error stack:', error instanceof Error ? error.stack : 'No stack trace')
+          logger.error('Transition execution failed', {
+            instanceId: currentInstance.id,
+            workflowId: currentInstance.workflowId,
+            fromStepId: currentInstance.currentStepId,
+            toStepId: selectedTransition.toStepId,
+            err: error,
+          })
           errors.push(errorMessage)
 
           events.push({
@@ -540,10 +554,7 @@ export async function executeWorkflow(
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error)
-      console.error(`[WORKFLOW] Execution failed (instance: ${instanceId}):`, error)
-      if (error instanceof Error && error.stack) {
-        console.error('[WORKFLOW] Error stack:', error.stack)
-      }
+      logger.error('Execution failed', { instanceId, err: error })
       errors.push(errorMessage)
 
       try {
@@ -564,7 +575,7 @@ export async function executeWorkflow(
           })
         }
       } catch (updateError) {
-        console.error(`[WORKFLOW] Failed to update instance ${instanceId} with error state:`, updateError)
+        logger.error('Failed to update instance with error state', { instanceId, err: updateError })
       }
 
       throw error
@@ -625,15 +636,17 @@ export async function completeWorkflow(
           }
         )
 
-        console.log(
-          `[Workflow] Compensation ${compensationResult.status}: ${compensationResult.compensatedActivities}/${compensationResult.totalActivities} activities`
-        )
+        logger.info('Compensation finished', {
+          status: compensationResult.status,
+          compensatedActivities: compensationResult.compensatedActivities,
+          totalActivities: compensationResult.totalActivities,
+        })
 
         // Note: instance status already updated by compensateWorkflow
         // It will be COMPENSATED or remain FAILED
         return
       } catch (error: any) {
-        console.error(`[Workflow] Compensation failed with exception:`, error)
+        logger.error('Compensation failed with exception', { err: error })
         // Continue to mark workflow as failed
       }
     }
@@ -800,7 +813,7 @@ export async function resumeWorkflowAfterActivities(
     const pendingTransition = instance.pendingTransition
 
     if (!pendingTransition) {
-      console.warn('[WORKFLOW] No pending transition found during resume')
+      logger.warn('No pending transition found during resume')
       instance.status = 'RUNNING'
       await trx.flush()
 
@@ -818,9 +831,9 @@ export async function resumeWorkflowAfterActivities(
       return { continueExecution: true }
     }
 
-    console.log('[WORKFLOW] Completing pending transition:', {
+    logger.debug('Completing pending transition', {
       toStepId: pendingTransition.toStepId,
-      from: instance.currentStepId,
+      fromStepId: instance.currentStepId,
     })
 
     const definition = await trx.findOneOrFail(WorkflowDefinition, {

package/src/modules/workflows/subscribers/event-trigger.ts

@@ -8,7 +8,9 @@
 
 import type { EntityManager } from '@mikro-orm/core'
 import type { AwilixContainer } from 'awilix'
-import { parseBooleanWithDefault } from '@open-mercato/shared/lib/boolean'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows').child({ component: 'event-trigger' })
 
 export const metadata = {
   event: '*', // Subscribe to ALL events
@@ -25,12 +27,6 @@ const EXCLUDED_EVENT_PREFIXES = [
   'queue.', // Queue events
 ]
 
-const WORKFLOW_TRIGGER_DEBUG_ENV = 'OM_WORKFLOW_TRIGGER_DEBUG'
-
-function isWorkflowTriggerDebugEnabled(): boolean {
-  return parseBooleanWithDefault(process.env[WORKFLOW_TRIGGER_DEBUG_ENV], false)
-}
-
 /**
  * Check if an event should be excluded from trigger processing.
  */
@@ -49,7 +45,7 @@ export default async function handle(
 ): Promise<void> {
   const eventName = ctx.eventName
   if (!eventName) {
-    console.warn('[workflow-trigger] Skipping trigger evaluation because subscriber context is missing eventName')
+    logger.warn('Skipping trigger evaluation because subscriber context is missing eventName')
     return
   }
 
@@ -90,7 +86,7 @@ export default async function handle(
     } as unknown as AwilixContainer
   } catch (error) {
     // DI not available - skip
-    console.warn(`[workflow-trigger] Cannot resolve dependencies for event "${eventName}":`, error)
+    logger.warn('Cannot resolve dependencies for event', { event: eventName, err: error })
     return
   }
 
@@ -105,29 +101,31 @@ export default async function handle(
       organizationId,
     })
 
-    if (isWorkflowTriggerDebugEnabled()) {
-      const matched = result.triggered + result.skipped + result.errors.length
-      console.log(
-        `[workflow-trigger] Evaluated triggers for "${eventName}": ` +
-        `tenant=${tenantId} organization=${organizationId} matched=${matched} ` +
-        `triggered=${result.triggered} skipped=${result.skipped} errors=${result.errors.length}`
-      )
-    }
+    logger.debug('Evaluated triggers', {
+      event: eventName,
+      tenantId,
+      organizationId,
+      matched: result.triggered + result.skipped + result.errors.length,
+      triggered: result.triggered,
+      skipped: result.skipped,
+      errors: result.errors.length,
+    })
 
     if (result.triggered > 0) {
-      console.log(
-        `[workflow-trigger] Triggered ${result.triggered} workflow(s) for "${eventName}"` +
-        (result.skipped > 0 ? ` (${result.skipped} skipped)` : '') +
-        (result.errors.length > 0 ? ` (${result.errors.length} errors)` : '')
-      )
+      logger.info('Triggered workflows for event', {
+        event: eventName,
+        triggered: result.triggered,
+        skipped: result.skipped,
+        errors: result.errors.length,
+      })
     }
 
     if (result.errors.length > 0) {
       for (const err of result.errors) {
-        console.error(`[workflow-trigger] Trigger ${err.triggerId} failed:`, err.error)
+        logger.error('Trigger failed', { triggerId: err.triggerId, err: err.error })
       }
     }
   } catch (error) {
-    console.error(`[workflow-trigger] Error processing triggers for "${eventName}":`, error)
+    logger.error('Error processing triggers for event', { event: eventName, err: error })
   }
 }

package/src/modules/workflows/subscribers/task-assigned-notification.ts

@@ -2,6 +2,9 @@ import type { EntityManager } from '@mikro-orm/postgresql'
 import { resolveNotificationService } from '../../notifications/lib/notificationService'
 import { buildNotificationFromType } from '../../notifications/lib/notificationBuilder'
 import { notificationTypes } from '../notifications'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows')
 
 export const metadata = {
   event: 'workflows.task.assigned',
@@ -48,6 +51,6 @@ export default async function handle(payload: TaskAssignedPayload, ctx: Resolver
       organizationId: payload.organizationId ?? null,
     })
   } catch (err) {
-    console.error('[workflows:task-assigned-notification] Failed to create notification:', err)
+    logger.error('Failed to create notification', { component: 'task-assigned-notification', err })
   }
 }

package/src/modules/workflows/workers/workflow-activities.worker.ts

@@ -22,6 +22,9 @@ import {
   executeCallWebhook,
   executeFunction,
 } from '../lib/activity-executor'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+
+const logger = createLogger('workflows').child({ component: 'activity-worker' })
 
 // Worker metadata for auto-discovery.
 // NOTE: `queue` MUST be a string literal (or locally-declared const) so the
@@ -70,9 +73,7 @@ export default async function handle(
   // Timer jobs (kind: 'timer') are a distinct flow — they resume a paused
   // workflow at a WAIT_FOR_TIMER step rather than running an activity.
   if (payload.kind === 'timer') {
-    console.log(
-      `[workflows:activity-worker] Firing timer for instance ${payload.workflowInstanceId} (job ${ctx.jobId})`
-    )
+    logger.debug('Firing timer for instance', { instanceId: payload.workflowInstanceId, jobId: ctx.jobId })
     const { fireTimer } = await import('../lib/timer-handler')
     await fireTimer(em, container, {
       instanceId: payload.workflowInstanceId,
@@ -85,9 +86,13 @@ export default async function handle(
     return
   }
 
-  console.log(
-    `[workflows:activity-worker] Processing activity ${payload.activityId} (${payload.activityType}) for workflow instance ${payload.workflowInstanceId} (job ${ctx.jobId}, attempt ${ctx.attemptNumber})`
-  )
+  logger.debug('Processing activity', {
+    activityId: payload.activityId,
+    activityType: payload.activityType,
+    instanceId: payload.workflowInstanceId,
+    jobId: ctx.jobId,
+    attemptNumber: ctx.attemptNumber,
+  })
 
   try {
     // Fetch workflow instance with tenant/org scoping
@@ -196,19 +201,25 @@ export default async function handle(
       organizationId: payload.organizationId,
     })
 
-    console.log(
-      `[workflows:activity-worker] Activity ${payload.activityId} (${payload.activityType}) completed successfully for workflow instance ${payload.workflowInstanceId} in ${executionTimeMs}ms`
-    )
+    logger.debug('Activity completed', {
+      activityId: payload.activityId,
+      activityType: payload.activityType,
+      instanceId: payload.workflowInstanceId,
+      executionTimeMs,
+    })
 
     // Attempt to resume workflow if all activities complete
     await checkAndResumeWorkflow(em, ctx, payload.workflowInstanceId, payload.branchInstanceId)
   } catch (error: any) {
     const executionTimeMs = Date.now() - startTime
 
-    console.error(
-      `[workflows:activity-worker] Activity ${payload.activityId} (${payload.activityType}) failed for workflow instance ${payload.workflowInstanceId} (attempt ${ctx.attemptNumber}):`,
-      error.message
-    )
+    logger.error('Activity failed', {
+      activityId: payload.activityId,
+      activityType: payload.activityType,
+      instanceId: payload.workflowInstanceId,
+      attemptNumber: ctx.attemptNumber,
+      err: error,
+    })
 
     // Log failure event to workflow event log
     await logWorkflowEvent(em, {
@@ -235,9 +246,12 @@ export default async function handle(
     // Check if this was final attempt (BullMQ handles retries automatically)
     const maxAttempts = payload.retryPolicy?.maxAttempts || 1
     if (ctx.attemptNumber >= maxAttempts) {
-      console.error(
-        `[workflows:activity-worker] Activity ${payload.activityId} (${payload.activityType}) failed after ${maxAttempts} attempts for workflow instance ${payload.workflowInstanceId} - triggering workflow failure handling`
-      )
+      logger.error('Activity failed after all attempts - triggering workflow failure handling', {
+        activityId: payload.activityId,
+        activityType: payload.activityType,
+        maxAttempts,
+        instanceId: payload.workflowInstanceId,
+      })
       // Final failure - attempt to resume workflow (may transition to FAILED state)
       await checkAndResumeWorkflow(em, ctx, payload.workflowInstanceId, payload.branchInstanceId)
     }
@@ -274,10 +288,7 @@ async function checkAndResumeWorkflow(
   } catch (error: any) {
     // Ignore error if workflow not ready to resume yet (activities still pending)
     if (!error.message?.includes('Activities still pending')) {
-      console.error(
-        `[workflows:activity-worker] Failed to resume workflow instance ${workflowInstanceId}:`,
-        error.message
-      )
+      logger.error('Failed to resume workflow instance', { instanceId: workflowInstanceId, err: error })
     }
   }
 }