@blokjs/trigger-cron 0.6.17 → 0.6.19

package/dist/CronTrigger.js

@@ -9,7 +9,7 @@
  *
  * Uses the 'cron' package for cron parsing and scheduling.
  */
-import { DefaultLogger, NodeMap, TriggerBase, } from "@blokjs/runner";
+import { DefaultLogger, DeferredDispatchSignal, NodeMap, TriggerBase, WaitDispatchRequest, } from "@blokjs/runner";
 import { SpanStatusCode, metrics, trace } from "@opentelemetry/api";
 import { CronJob } from "cron";
 import { v4 as uuid } from "uuid";
@@ -58,6 +58,19 @@ export class CronTrigger extends TriggerBase {
     async listen() {
         const startTime = this.startCounter();
         try {
+            // F5 · install crash/orphan/janitor/shutdown handlers so a
+            // cron-only process gets the same run-state integrity + storage
+            // hygiene guarantees as HTTP/Worker. Each handler is idempotent
+            // + individually kill-switched.
+            this.installOperationalHandlers(this.logger);
+            // F6 · feed the WorkflowRegistry from the nodeMap so `subworkflow:`
+            // steps + trigger/workflow/process-global middleware resolve in a
+            // cron-only deployment (no HTTP trigger to populate the registry).
+            this.registerWorkflowsFromNodeMap(this.logger);
+            // F14 · seed the process-global middleware chain from
+            // `BLOK_GLOBAL_MIDDLEWARE` (idempotent — programmatic
+            // setGlobalMiddleware takes precedence).
+            this.seedGlobalMiddlewareFromEnv(this.logger);
             // Find all workflows with cron triggers
             const cronWorkflows = this.getCronWorkflows();
             if (cronWorkflows.length === 0) {
@@ -288,6 +301,29 @@ export class CronTrigger extends TriggerBase {
                     resolve(response);
                 }
                 catch (error) {
+                    // F5 · a cron workflow with a `wait` step (or a scheduling
+                    // gate) throws DeferredDispatchSignal / WaitDispatchRequest
+                    // to defer the run — that's a successful deferral, NOT a
+                    // failure. TriggerBase.run already marked the run
+                    // delayed/queued/debounced and (for HTTP) persisted the
+                    // dispatch. Cron's in-process scheduler owns the eventual
+                    // re-fire, so we just record success and don't bump
+                    // `cron_errors`.
+                    if (error instanceof DeferredDispatchSignal || error instanceof WaitDispatchRequest) {
+                        span.setAttribute("success", true);
+                        span.setAttribute("deferred", true);
+                        span.setStatus({ code: SpanStatusCode.OK });
+                        cronExecutions.add(1, {
+                            env: process.env.NODE_ENV,
+                            job_id: jobId,
+                            workflow_name: this.configuration.name,
+                            manual: String(manual),
+                            success: "true",
+                        });
+                        this.logger.log(`Cron job deferred ${jobId}: ${error.message}`);
+                        resolve({ ctx: {}, metrics: {} });
+                        return;
+                    }
                     const errorMessage = error.message;
                     // Set span error
                     span.setAttribute("success", false);
@@ -312,4 +348,4 @@ export class CronTrigger extends TriggerBase {
     }
 }
 export default CronTrigger;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CronTrigger.js","sourceRoot":"","sources":["../src/CronTrigger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CronTrigger - Scheduled workflow execution based on cron expressions\n *\n * Extends TriggerBase to support scheduled triggers:\n * - Cron expressions (e.g., \"0 * * * *\" for hourly)\n * - Timezone-aware scheduling\n * - Overlap prevention\n * - Manual trigger support\n *\n * Uses the 'cron' package for cron parsing and scheduling.\n */\n\nimport type { CronTriggerOpts, HelperResponse } from \"@blokjs/helper\";\nimport {\n\ttype BlokService,\n\tDefaultLogger,\n\ttype GlobalOptions,\n\tNodeMap,\n\tTriggerBase,\n\ttype TriggerResponse,\n} from \"@blokjs/runner\";\nimport type { Context, MetricsType, RequestContext } from \"@blokjs/shared\";\nimport { type Span, SpanStatusCode, metrics, trace } from \"@opentelemetry/api\";\nimport { CronJob } from \"cron\";\nimport { v4 as uuid } from \"uuid\";\n\n/**\n * Scheduled job information\n */\nexport interface ScheduledJob {\n\t/** Unique job ID */\n\tid: string;\n\t/** Workflow path */\n\tworkflowPath: string;\n\t/** Cron expression */\n\tschedule: string;\n\t/** Timezone */\n\ttimezone: string;\n\t/** Allow overlapping executions */\n\toverlap: boolean;\n\t/** Whether the job is currently running */\n\trunning: boolean;\n\t/** Last execution time */\n\tlastRun?: Date;\n\t/** Next scheduled time */\n\tnextRun?: Date;\n\t/** Internal CronJob instance */\n\tjob: CronJob;\n}\n\n/**\n * Execution context passed to the workflow\n */\nexport interface CronExecutionContext {\n\t/** Job ID */\n\tjobId: string;\n\t/** Scheduled time (when it was supposed to run) */\n\tscheduledTime: Date;\n\t/** Actual execution time */\n\texecutionTime: Date;\n\t/** Cron expression */\n\tschedule: string;\n\t/** Timezone */\n\ttimezone: string;\n\t/** Whether this is a manual trigger */\n\tmanual: boolean;\n}\n\n/**\n * Workflow model with cron trigger configuration\n */\ninterface CronWorkflowModel {\n\tpath: string;\n\tconfig: {\n\t\tname: string;\n\t\tversion: string;\n\t\ttrigger?: {\n\t\t\tcron?: CronTriggerOpts;\n\t\t\t[key: string]: unknown;\n\t\t};\n\t\t[key: string]: unknown;\n\t};\n}\n\n/**\n * CronTrigger - Scheduled workflow execution\n */\nexport abstract class CronTrigger extends TriggerBase {\n\tprotected nodeMap: GlobalOptions = {} as GlobalOptions;\n\tprotected readonly tracer = trace.getTracer(\n\t\tprocess.env.PROJECT_NAME || \"trigger-cron-workflow\",\n\t\tprocess.env.PROJECT_VERSION || \"0.0.1\",\n\t);\n\tprotected readonly logger = new DefaultLogger();\n\tprotected jobs: Map<string, ScheduledJob> = new Map();\n\n\t// Subclasses provide these\n\tprotected abstract nodes: Record<string, BlokService<unknown>>;\n\tprotected abstract workflows: Record<string, HelperResponse>;\n\n\tconstructor() {\n\t\tsuper();\n\t\tthis.loadNodes();\n\t\tthis.loadWorkflows();\n\t}\n\n\t/**\n\t * Load nodes into the node map\n\t */\n\tloadNodes(): void {\n\t\tthis.nodeMap.nodes = new NodeMap();\n\t\tconst nodeKeys = Object.keys(this.nodes);\n\t\tfor (const key of nodeKeys) {\n\t\t\tthis.nodeMap.nodes.addNode(key, this.nodes[key]);\n\t\t}\n\t}\n\n\t/**\n\t * Load workflows into the workflow map\n\t */\n\tloadWorkflows(): void {\n\t\tthis.nodeMap.workflows = this.workflows;\n\t}\n\n\t/**\n\t * Convert cron DateTime to Date\n\t * The cron package uses luxon DateTime which has toJSDate()\n\t */\n\tprotected toDate(dateTime: unknown): Date {\n\t\tif (dateTime && typeof dateTime === \"object\" && \"toJSDate\" in dateTime) {\n\t\t\treturn (dateTime as { toJSDate: () => Date }).toJSDate();\n\t\t}\n\t\treturn dateTime instanceof Date ? dateTime : new Date(dateTime as string | number);\n\t}\n\n\t/**\n\t * Start the cron scheduler - main entry point\n\t */\n\tasync listen(): Promise<number> {\n\t\tconst startTime = this.startCounter();\n\n\t\ttry {\n\t\t\t// Find all workflows with cron triggers\n\t\t\tconst cronWorkflows = this.getCronWorkflows();\n\n\t\t\tif (cronWorkflows.length === 0) {\n\t\t\t\tthis.logger.log(\"No workflows with cron triggers found\");\n\t\t\t\treturn this.endCounter(startTime);\n\t\t\t}\n\n\t\t\t// Create and start cron jobs for each workflow\n\t\t\tfor (const workflow of cronWorkflows) {\n\t\t\t\tconst config = workflow.config.trigger?.cron as CronTriggerOpts;\n\t\t\t\tconst jobId = `cron-${workflow.path}-${uuid().slice(0, 8)}`;\n\n\t\t\t\t// `CronTriggerOpts` is `z.input<…>` so `timezone` is `string | undefined`\n\t\t\t\t// even though the schema declares `.default(\"UTC\")`. Apply the\n\t\t\t\t// default once here so the rest of this method (and the cron lib's\n\t\t\t\t// constructor) sees a guaranteed string.\n\t\t\t\tconst timezone = config.timezone ?? \"UTC\";\n\n\t\t\t\tthis.logger.log(`Scheduling workflow: ${workflow.path} with schedule: ${config.schedule} (${timezone})`);\n\n\t\t\t\tconst job = new CronJob(\n\t\t\t\t\tconfig.schedule,\n\t\t\t\t\tasync () => {\n\t\t\t\t\t\tawait this.executeWorkflow(jobId, workflow, config, false);\n\t\t\t\t\t},\n\t\t\t\t\tnull, // onComplete\n\t\t\t\t\tfalse, // start\n\t\t\t\t\ttimezone,\n\t\t\t\t);\n\n\t\t\t\tconst scheduledJob: ScheduledJob = {\n\t\t\t\t\tid: jobId,\n\t\t\t\t\tworkflowPath: workflow.path,\n\t\t\t\t\tschedule: config.schedule,\n\t\t\t\t\ttimezone,\n\t\t\t\t\toverlap: config.overlap ?? false,\n\t\t\t\t\trunning: false,\n\t\t\t\t\tnextRun: this.toDate(job.nextDate()),\n\t\t\t\t\tjob,\n\t\t\t\t};\n\n\t\t\t\tthis.jobs.set(jobId, scheduledJob);\n\n\t\t\t\t// Start the job\n\t\t\t\tjob.start();\n\t\t\t\tthis.logger.log(`Job ${jobId} started. Next run: ${scheduledJob.nextRun}`);\n\t\t\t}\n\n\t\t\tthis.logger.log(`Cron trigger started. ${this.jobs.size} job(s) scheduled`);\n\n\t\t\t// Enable HMR in development mode\n\t\t\tif (process.env.BLOK_HMR === \"true\" || process.env.NODE_ENV === \"development\") {\n\t\t\t\tawait this.enableHotReload();\n\t\t\t}\n\n\t\t\treturn this.endCounter(startTime);\n\t\t} catch (error) {\n\t\t\tthis.logger.error(`Failed to start cron trigger: ${(error as Error).message}`);\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\t/**\n\t * Stop all cron jobs\n\t */\n\tasync stop(): Promise<void> {\n\t\tfor (const [jobId, scheduledJob] of this.jobs) {\n\t\t\tscheduledJob.job.stop();\n\t\t\tthis.logger.log(`Job ${jobId} stopped`);\n\t\t}\n\t\tthis.jobs.clear();\n\t\tthis.logger.log(\"Cron trigger stopped\");\n\t}\n\n\tprotected override async onHmrWorkflowChange(): Promise<void> {\n\t\tthis.logger.log(\"[HMR] Cron workflow changed, reloading...\");\n\t\tawait this.waitForInFlightRequests();\n\t\tawait this.stop();\n\t\tthis.loadWorkflows();\n\t\tawait this.listen();\n\t}\n\n\t/**\n\t * Manually trigger a specific job\n\t */\n\tasync triggerJob(jobId: string): Promise<TriggerResponse | null> {\n\t\tconst scheduledJob = this.jobs.get(jobId);\n\t\tif (!scheduledJob) {\n\t\t\tthis.logger.error(`Job not found: ${jobId}`);\n\t\t\treturn null;\n\t\t}\n\n\t\t// Get the workflow\n\t\tconst workflow = this.getWorkflowByPath(scheduledJob.workflowPath);\n\t\tif (!workflow) {\n\t\t\tthis.logger.error(`Workflow not found: ${scheduledJob.workflowPath}`);\n\t\t\treturn null;\n\t\t}\n\n\t\tconst config = workflow.config.trigger?.cron as CronTriggerOpts;\n\t\treturn this.executeWorkflow(jobId, workflow, config, true);\n\t}\n\n\t/**\n\t * Get all scheduled jobs\n\t */\n\tgetJobs(): ScheduledJob[] {\n\t\treturn Array.from(this.jobs.values()).map((job) => ({\n\t\t\t...job,\n\t\t\tnextRun: this.toDate(job.job.nextDate()),\n\t\t}));\n\t}\n\n\t/**\n\t * Get all workflows that have cron triggers\n\t */\n\tprotected getCronWorkflows(): CronWorkflowModel[] {\n\t\tconst workflows: CronWorkflowModel[] = [];\n\n\t\tfor (const [path, workflow] of Object.entries(this.nodeMap.workflows || {})) {\n\t\t\tconst workflowConfig = (workflow as unknown as { _config: CronWorkflowModel[\"config\"] })._config;\n\n\t\t\tif (workflowConfig?.trigger) {\n\t\t\t\tconst triggerType = Object.keys(workflowConfig.trigger)[0];\n\n\t\t\t\tif (triggerType === \"cron\" && workflowConfig.trigger.cron) {\n\t\t\t\t\tworkflows.push({\n\t\t\t\t\t\tpath,\n\t\t\t\t\t\tconfig: workflowConfig,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn workflows;\n\t}\n\n\t/**\n\t * Get workflow by path\n\t */\n\tprotected getWorkflowByPath(path: string): CronWorkflowModel | null {\n\t\tconst workflow = this.nodeMap.workflows?.[path];\n\t\tif (!workflow) return null;\n\n\t\tconst workflowConfig = (workflow as unknown as { _config: CronWorkflowModel[\"config\"] })._config;\n\t\treturn {\n\t\t\tpath,\n\t\t\tconfig: workflowConfig,\n\t\t};\n\t}\n\n\t/**\n\t * Execute a workflow\n\t */\n\tprotected async executeWorkflow(\n\t\tjobId: string,\n\t\tworkflow: CronWorkflowModel,\n\t\tconfig: CronTriggerOpts,\n\t\tmanual: boolean,\n\t): Promise<TriggerResponse> {\n\t\tconst scheduledJob = this.jobs.get(jobId);\n\t\tif (!scheduledJob) {\n\t\t\tthrow new Error(`Job not found: ${jobId}`);\n\t\t}\n\n\t\t// Check for overlap\n\t\tif (scheduledJob.running && !scheduledJob.overlap) {\n\t\t\tthis.logger.log(`Skipping ${jobId}: previous execution still running (overlap disabled)`);\n\t\t\treturn { ctx: {} as Context, metrics: {} as MetricsType };\n\t\t}\n\n\t\tconst executionId = uuid();\n\t\tconst lastDate = scheduledJob.job.lastDate();\n\t\tconst scheduledTime = lastDate ? new Date(lastDate as unknown as string | number) : new Date();\n\t\tconst executionTime = new Date();\n\n\t\t// Apply the schema default — see explanation in `listen()`.\n\t\tconst timezone = config.timezone ?? \"UTC\";\n\n\t\tconst defaultMeter = metrics.getMeter(\"default\");\n\t\tconst cronExecutions = defaultMeter.createCounter(\"cron_executions\", {\n\t\t\tdescription: \"Cron job executions\",\n\t\t});\n\t\tconst cronErrors = defaultMeter.createCounter(\"cron_errors\", {\n\t\t\tdescription: \"Cron job execution errors\",\n\t\t});\n\n\t\treturn new Promise((resolve) => {\n\t\t\tthis.tracer.startActiveSpan(`cron:${workflow.path}`, async (span: Span) => {\n\t\t\t\tscheduledJob.running = true;\n\n\t\t\t\ttry {\n\t\t\t\t\tconst start = performance.now();\n\n\t\t\t\t\t// Initialize configuration for this workflow\n\t\t\t\t\tawait this.configuration.init(workflow.path, this.nodeMap);\n\n\t\t\t\t\t// Create context\n\t\t\t\t\tconst ctx: Context = this.createContext(undefined, workflow.path, executionId);\n\n\t\t\t\t\t// Create execution context\n\t\t\t\t\tconst cronContext: CronExecutionContext = {\n\t\t\t\t\t\tjobId,\n\t\t\t\t\t\tscheduledTime,\n\t\t\t\t\t\texecutionTime,\n\t\t\t\t\t\tschedule: config.schedule,\n\t\t\t\t\t\ttimezone,\n\t\t\t\t\t\tmanual,\n\t\t\t\t\t};\n\n\t\t\t\t\t// Populate request with cron context\n\t\t\t\t\tctx.request = {\n\t\t\t\t\t\tbody: cronContext,\n\t\t\t\t\t\theaders: {\n\t\t\t\t\t\t\t\"x-cron-job-id\": jobId,\n\t\t\t\t\t\t\t\"x-cron-schedule\": config.schedule,\n\t\t\t\t\t\t\t\"x-cron-timezone\": config.timezone,\n\t\t\t\t\t\t\t\"x-cron-manual\": String(manual),\n\t\t\t\t\t\t},\n\t\t\t\t\t\tquery: {},\n\t\t\t\t\t\tparams: {\n\t\t\t\t\t\t\tjobId,\n\t\t\t\t\t\t\tschedule: config.schedule,\n\t\t\t\t\t\t},\n\t\t\t\t\t} as unknown as RequestContext;\n\n\t\t\t\t\t// Store cron context in vars\n\t\t\t\t\tif (!ctx.vars) ctx.vars = {};\n\t\t\t\t\tctx.vars._cron_context = {\n\t\t\t\t\t\tjobId,\n\t\t\t\t\t\tscheduledTime: scheduledTime.toISOString(),\n\t\t\t\t\t\texecutionTime: executionTime.toISOString(),\n\t\t\t\t\t\tschedule: config.schedule,\n\t\t\t\t\t\ttimezone: config.timezone,\n\t\t\t\t\t\tmanual: String(manual),\n\t\t\t\t\t};\n\n\t\t\t\t\tctx.logger.log(`Executing cron job: ${jobId} (${manual ? \"manual\" : \"scheduled\"})`);\n\n\t\t\t\t\t// v0.6 · apply the merged middleware chain (process-global →\n\t\t\t\t\t// workflow-level → trigger-level) before the main workflow\n\t\t\t\t\t// body. Lets cron workflows compose auth-check + audit-log\n\t\t\t\t\t// chains exactly like HTTP triggers. A throwing middleware\n\t\t\t\t\t// propagates to the outer catch and surfaces as a cron job\n\t\t\t\t\t// failure.\n\t\t\t\t\tawait this.applyMiddlewareChain(ctx, this.nodeMap);\n\n\t\t\t\t\t// Execute workflow\n\t\t\t\t\tconst response: TriggerResponse = await this.run(ctx);\n\t\t\t\t\tconst end = performance.now();\n\n\t\t\t\t\t// Update job state\n\t\t\t\t\tscheduledJob.lastRun = executionTime;\n\t\t\t\t\tscheduledJob.nextRun = this.toDate(scheduledJob.job.nextDate());\n\n\t\t\t\t\t// Set span attributes\n\t\t\t\t\tspan.setAttribute(\"success\", true);\n\t\t\t\t\tspan.setAttribute(\"job_id\", jobId);\n\t\t\t\t\tspan.setAttribute(\"workflow_path\", workflow.path);\n\t\t\t\t\tspan.setAttribute(\"schedule\", config.schedule);\n\t\t\t\t\tspan.setAttribute(\"timezone\", timezone);\n\t\t\t\t\tspan.setAttribute(\"manual\", manual);\n\t\t\t\t\tspan.setAttribute(\"elapsed_ms\", end - start);\n\t\t\t\t\tspan.setStatus({ code: SpanStatusCode.OK });\n\n\t\t\t\t\t// Record metrics\n\t\t\t\t\tcronExecutions.add(1, {\n\t\t\t\t\t\tenv: process.env.NODE_ENV,\n\t\t\t\t\t\tjob_id: jobId,\n\t\t\t\t\t\tworkflow_name: this.configuration.name,\n\t\t\t\t\t\tmanual: String(manual),\n\t\t\t\t\t\tsuccess: \"true\",\n\t\t\t\t\t});\n\n\t\t\t\t\tctx.logger.log(`Cron job completed in ${(end - start).toFixed(2)}ms: ${jobId}`);\n\n\t\t\t\t\tresolve(response);\n\t\t\t\t} catch (error) {\n\t\t\t\t\tconst errorMessage = (error as Error).message;\n\n\t\t\t\t\t// Set span error\n\t\t\t\t\tspan.setAttribute(\"success\", false);\n\t\t\t\t\tspan.recordException(error as Error);\n\t\t\t\t\tspan.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });\n\n\t\t\t\t\t// Record error metrics\n\t\t\t\t\tcronErrors.add(1, {\n\t\t\t\t\t\tenv: process.env.NODE_ENV,\n\t\t\t\t\t\tjob_id: jobId,\n\t\t\t\t\t\tworkflow_name: this.configuration?.name || \"unknown\",\n\t\t\t\t\t\tmanual: String(manual),\n\t\t\t\t\t});\n\n\t\t\t\t\tthis.logger.error(`Cron job failed ${jobId}: ${errorMessage}`, (error as Error).stack);\n\n\t\t\t\t\tresolve({ ctx: {} as Context, metrics: {} as MetricsType });\n\t\t\t\t} finally {\n\t\t\t\t\tscheduledJob.running = false;\n\t\t\t\t\tspan.end();\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t}\n}\n\nexport default CronTrigger;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CronTrigger.js","sourceRoot":"","sources":["../src/CronTrigger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CronTrigger - Scheduled workflow execution based on cron expressions\n *\n * Extends TriggerBase to support scheduled triggers:\n * - Cron expressions (e.g., \"0 * * * *\" for hourly)\n * - Timezone-aware scheduling\n * - Overlap prevention\n * - Manual trigger support\n *\n * Uses the 'cron' package for cron parsing and scheduling.\n */\n\nimport type { CronTriggerOpts, HelperResponse } from \"@blokjs/helper\";\nimport {\n\ttype BlokService,\n\tDefaultLogger,\n\tDeferredDispatchSignal,\n\ttype GlobalOptions,\n\tNodeMap,\n\tTriggerBase,\n\ttype TriggerResponse,\n\tWaitDispatchRequest,\n} from \"@blokjs/runner\";\nimport type { Context, MetricsType, RequestContext } from \"@blokjs/shared\";\nimport { type Span, SpanStatusCode, metrics, trace } from \"@opentelemetry/api\";\nimport { CronJob } from \"cron\";\nimport { v4 as uuid } from \"uuid\";\n\n/**\n * Scheduled job information\n */\nexport interface ScheduledJob {\n\t/** Unique job ID */\n\tid: string;\n\t/** Workflow path */\n\tworkflowPath: string;\n\t/** Cron expression */\n\tschedule: string;\n\t/** Timezone */\n\ttimezone: string;\n\t/** Allow overlapping executions */\n\toverlap: boolean;\n\t/** Whether the job is currently running */\n\trunning: boolean;\n\t/** Last execution time */\n\tlastRun?: Date;\n\t/** Next scheduled time */\n\tnextRun?: Date;\n\t/** Internal CronJob instance */\n\tjob: CronJob;\n}\n\n/**\n * Execution context passed to the workflow\n */\nexport interface CronExecutionContext {\n\t/** Job ID */\n\tjobId: string;\n\t/** Scheduled time (when it was supposed to run) */\n\tscheduledTime: Date;\n\t/** Actual execution time */\n\texecutionTime: Date;\n\t/** Cron expression */\n\tschedule: string;\n\t/** Timezone */\n\ttimezone: string;\n\t/** Whether this is a manual trigger */\n\tmanual: boolean;\n}\n\n/**\n * Workflow model with cron trigger configuration\n */\ninterface CronWorkflowModel {\n\tpath: string;\n\tconfig: {\n\t\tname: string;\n\t\tversion: string;\n\t\ttrigger?: {\n\t\t\tcron?: CronTriggerOpts;\n\t\t\t[key: string]: unknown;\n\t\t};\n\t\t[key: string]: unknown;\n\t};\n}\n\n/**\n * CronTrigger - Scheduled workflow execution\n */\nexport abstract class CronTrigger extends TriggerBase {\n\tprotected nodeMap: GlobalOptions = {} as GlobalOptions;\n\tprotected readonly tracer = trace.getTracer(\n\t\tprocess.env.PROJECT_NAME || \"trigger-cron-workflow\",\n\t\tprocess.env.PROJECT_VERSION || \"0.0.1\",\n\t);\n\tprotected readonly logger = new DefaultLogger();\n\tprotected jobs: Map<string, ScheduledJob> = new Map();\n\n\t// Subclasses provide these\n\tprotected abstract nodes: Record<string, BlokService<unknown>>;\n\tprotected abstract workflows: Record<string, HelperResponse>;\n\n\tconstructor() {\n\t\tsuper();\n\t\tthis.loadNodes();\n\t\tthis.loadWorkflows();\n\t}\n\n\t/**\n\t * Load nodes into the node map\n\t */\n\tloadNodes(): void {\n\t\tthis.nodeMap.nodes = new NodeMap();\n\t\tconst nodeKeys = Object.keys(this.nodes);\n\t\tfor (const key of nodeKeys) {\n\t\t\tthis.nodeMap.nodes.addNode(key, this.nodes[key]);\n\t\t}\n\t}\n\n\t/**\n\t * Load workflows into the workflow map\n\t */\n\tloadWorkflows(): void {\n\t\tthis.nodeMap.workflows = this.workflows;\n\t}\n\n\t/**\n\t * Convert cron DateTime to Date\n\t * The cron package uses luxon DateTime which has toJSDate()\n\t */\n\tprotected toDate(dateTime: unknown): Date {\n\t\tif (dateTime && typeof dateTime === \"object\" && \"toJSDate\" in dateTime) {\n\t\t\treturn (dateTime as { toJSDate: () => Date }).toJSDate();\n\t\t}\n\t\treturn dateTime instanceof Date ? dateTime : new Date(dateTime as string | number);\n\t}\n\n\t/**\n\t * Start the cron scheduler - main entry point\n\t */\n\tasync listen(): Promise<number> {\n\t\tconst startTime = this.startCounter();\n\n\t\ttry {\n\t\t\t// F5 · install crash/orphan/janitor/shutdown handlers so a\n\t\t\t// cron-only process gets the same run-state integrity + storage\n\t\t\t// hygiene guarantees as HTTP/Worker. Each handler is idempotent\n\t\t\t// + individually kill-switched.\n\t\t\tthis.installOperationalHandlers(this.logger);\n\n\t\t\t// F6 · feed the WorkflowRegistry from the nodeMap so `subworkflow:`\n\t\t\t// steps + trigger/workflow/process-global middleware resolve in a\n\t\t\t// cron-only deployment (no HTTP trigger to populate the registry).\n\t\t\tthis.registerWorkflowsFromNodeMap(this.logger);\n\n\t\t\t// F14 · seed the process-global middleware chain from\n\t\t\t// `BLOK_GLOBAL_MIDDLEWARE` (idempotent — programmatic\n\t\t\t// setGlobalMiddleware takes precedence).\n\t\t\tthis.seedGlobalMiddlewareFromEnv(this.logger);\n\n\t\t\t// Find all workflows with cron triggers\n\t\t\tconst cronWorkflows = this.getCronWorkflows();\n\n\t\t\tif (cronWorkflows.length === 0) {\n\t\t\t\tthis.logger.log(\"No workflows with cron triggers found\");\n\t\t\t\treturn this.endCounter(startTime);\n\t\t\t}\n\n\t\t\t// Create and start cron jobs for each workflow\n\t\t\tfor (const workflow of cronWorkflows) {\n\t\t\t\tconst config = workflow.config.trigger?.cron as CronTriggerOpts;\n\t\t\t\tconst jobId = `cron-${workflow.path}-${uuid().slice(0, 8)}`;\n\n\t\t\t\t// `CronTriggerOpts` is `z.input<…>` so `timezone` is `string | undefined`\n\t\t\t\t// even though the schema declares `.default(\"UTC\")`. Apply the\n\t\t\t\t// default once here so the rest of this method (and the cron lib's\n\t\t\t\t// constructor) sees a guaranteed string.\n\t\t\t\tconst timezone = config.timezone ?? \"UTC\";\n\n\t\t\t\tthis.logger.log(`Scheduling workflow: ${workflow.path} with schedule: ${config.schedule} (${timezone})`);\n\n\t\t\t\tconst job = new CronJob(\n\t\t\t\t\tconfig.schedule,\n\t\t\t\t\tasync () => {\n\t\t\t\t\t\tawait this.executeWorkflow(jobId, workflow, config, false);\n\t\t\t\t\t},\n\t\t\t\t\tnull, // onComplete\n\t\t\t\t\tfalse, // start\n\t\t\t\t\ttimezone,\n\t\t\t\t);\n\n\t\t\t\tconst scheduledJob: ScheduledJob = {\n\t\t\t\t\tid: jobId,\n\t\t\t\t\tworkflowPath: workflow.path,\n\t\t\t\t\tschedule: config.schedule,\n\t\t\t\t\ttimezone,\n\t\t\t\t\toverlap: config.overlap ?? false,\n\t\t\t\t\trunning: false,\n\t\t\t\t\tnextRun: this.toDate(job.nextDate()),\n\t\t\t\t\tjob,\n\t\t\t\t};\n\n\t\t\t\tthis.jobs.set(jobId, scheduledJob);\n\n\t\t\t\t// Start the job\n\t\t\t\tjob.start();\n\t\t\t\tthis.logger.log(`Job ${jobId} started. Next run: ${scheduledJob.nextRun}`);\n\t\t\t}\n\n\t\t\tthis.logger.log(`Cron trigger started. ${this.jobs.size} job(s) scheduled`);\n\n\t\t\t// Enable HMR in development mode\n\t\t\tif (process.env.BLOK_HMR === \"true\" || process.env.NODE_ENV === \"development\") {\n\t\t\t\tawait this.enableHotReload();\n\t\t\t}\n\n\t\t\treturn this.endCounter(startTime);\n\t\t} catch (error) {\n\t\t\tthis.logger.error(`Failed to start cron trigger: ${(error as Error).message}`);\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\t/**\n\t * Stop all cron jobs\n\t */\n\tasync stop(): Promise<void> {\n\t\tfor (const [jobId, scheduledJob] of this.jobs) {\n\t\t\tscheduledJob.job.stop();\n\t\t\tthis.logger.log(`Job ${jobId} stopped`);\n\t\t}\n\t\tthis.jobs.clear();\n\t\tthis.logger.log(\"Cron trigger stopped\");\n\t}\n\n\tprotected override async onHmrWorkflowChange(): Promise<void> {\n\t\tthis.logger.log(\"[HMR] Cron workflow changed, reloading...\");\n\t\tawait this.waitForInFlightRequests();\n\t\tawait this.stop();\n\t\tthis.loadWorkflows();\n\t\tawait this.listen();\n\t}\n\n\t/**\n\t * Manually trigger a specific job\n\t */\n\tasync triggerJob(jobId: string): Promise<TriggerResponse | null> {\n\t\tconst scheduledJob = this.jobs.get(jobId);\n\t\tif (!scheduledJob) {\n\t\t\tthis.logger.error(`Job not found: ${jobId}`);\n\t\t\treturn null;\n\t\t}\n\n\t\t// Get the workflow\n\t\tconst workflow = this.getWorkflowByPath(scheduledJob.workflowPath);\n\t\tif (!workflow) {\n\t\t\tthis.logger.error(`Workflow not found: ${scheduledJob.workflowPath}`);\n\t\t\treturn null;\n\t\t}\n\n\t\tconst config = workflow.config.trigger?.cron as CronTriggerOpts;\n\t\treturn this.executeWorkflow(jobId, workflow, config, true);\n\t}\n\n\t/**\n\t * Get all scheduled jobs\n\t */\n\tgetJobs(): ScheduledJob[] {\n\t\treturn Array.from(this.jobs.values()).map((job) => ({\n\t\t\t...job,\n\t\t\tnextRun: this.toDate(job.job.nextDate()),\n\t\t}));\n\t}\n\n\t/**\n\t * Get all workflows that have cron triggers\n\t */\n\tprotected getCronWorkflows(): CronWorkflowModel[] {\n\t\tconst workflows: CronWorkflowModel[] = [];\n\n\t\tfor (const [path, workflow] of Object.entries(this.nodeMap.workflows || {})) {\n\t\t\tconst workflowConfig = (workflow as unknown as { _config: CronWorkflowModel[\"config\"] })._config;\n\n\t\t\tif (workflowConfig?.trigger) {\n\t\t\t\tconst triggerType = Object.keys(workflowConfig.trigger)[0];\n\n\t\t\t\tif (triggerType === \"cron\" && workflowConfig.trigger.cron) {\n\t\t\t\t\tworkflows.push({\n\t\t\t\t\t\tpath,\n\t\t\t\t\t\tconfig: workflowConfig,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn workflows;\n\t}\n\n\t/**\n\t * Get workflow by path\n\t */\n\tprotected getWorkflowByPath(path: string): CronWorkflowModel | null {\n\t\tconst workflow = this.nodeMap.workflows?.[path];\n\t\tif (!workflow) return null;\n\n\t\tconst workflowConfig = (workflow as unknown as { _config: CronWorkflowModel[\"config\"] })._config;\n\t\treturn {\n\t\t\tpath,\n\t\t\tconfig: workflowConfig,\n\t\t};\n\t}\n\n\t/**\n\t * Execute a workflow\n\t */\n\tprotected async executeWorkflow(\n\t\tjobId: string,\n\t\tworkflow: CronWorkflowModel,\n\t\tconfig: CronTriggerOpts,\n\t\tmanual: boolean,\n\t): Promise<TriggerResponse> {\n\t\tconst scheduledJob = this.jobs.get(jobId);\n\t\tif (!scheduledJob) {\n\t\t\tthrow new Error(`Job not found: ${jobId}`);\n\t\t}\n\n\t\t// Check for overlap\n\t\tif (scheduledJob.running && !scheduledJob.overlap) {\n\t\t\tthis.logger.log(`Skipping ${jobId}: previous execution still running (overlap disabled)`);\n\t\t\treturn { ctx: {} as Context, metrics: {} as MetricsType };\n\t\t}\n\n\t\tconst executionId = uuid();\n\t\tconst lastDate = scheduledJob.job.lastDate();\n\t\tconst scheduledTime = lastDate ? new Date(lastDate as unknown as string | number) : new Date();\n\t\tconst executionTime = new Date();\n\n\t\t// Apply the schema default — see explanation in `listen()`.\n\t\tconst timezone = config.timezone ?? \"UTC\";\n\n\t\tconst defaultMeter = metrics.getMeter(\"default\");\n\t\tconst cronExecutions = defaultMeter.createCounter(\"cron_executions\", {\n\t\t\tdescription: \"Cron job executions\",\n\t\t});\n\t\tconst cronErrors = defaultMeter.createCounter(\"cron_errors\", {\n\t\t\tdescription: \"Cron job execution errors\",\n\t\t});\n\n\t\treturn new Promise((resolve) => {\n\t\t\tthis.tracer.startActiveSpan(`cron:${workflow.path}`, async (span: Span) => {\n\t\t\t\tscheduledJob.running = true;\n\n\t\t\t\ttry {\n\t\t\t\t\tconst start = performance.now();\n\n\t\t\t\t\t// Initialize configuration for this workflow\n\t\t\t\t\tawait this.configuration.init(workflow.path, this.nodeMap);\n\n\t\t\t\t\t// Create context\n\t\t\t\t\tconst ctx: Context = this.createContext(undefined, workflow.path, executionId);\n\n\t\t\t\t\t// Create execution context\n\t\t\t\t\tconst cronContext: CronExecutionContext = {\n\t\t\t\t\t\tjobId,\n\t\t\t\t\t\tscheduledTime,\n\t\t\t\t\t\texecutionTime,\n\t\t\t\t\t\tschedule: config.schedule,\n\t\t\t\t\t\ttimezone,\n\t\t\t\t\t\tmanual,\n\t\t\t\t\t};\n\n\t\t\t\t\t// Populate request with cron context\n\t\t\t\t\tctx.request = {\n\t\t\t\t\t\tbody: cronContext,\n\t\t\t\t\t\theaders: {\n\t\t\t\t\t\t\t\"x-cron-job-id\": jobId,\n\t\t\t\t\t\t\t\"x-cron-schedule\": config.schedule,\n\t\t\t\t\t\t\t\"x-cron-timezone\": config.timezone,\n\t\t\t\t\t\t\t\"x-cron-manual\": String(manual),\n\t\t\t\t\t\t},\n\t\t\t\t\t\tquery: {},\n\t\t\t\t\t\tparams: {\n\t\t\t\t\t\t\tjobId,\n\t\t\t\t\t\t\tschedule: config.schedule,\n\t\t\t\t\t\t},\n\t\t\t\t\t} as unknown as RequestContext;\n\n\t\t\t\t\t// Store cron context in vars\n\t\t\t\t\tif (!ctx.vars) ctx.vars = {};\n\t\t\t\t\tctx.vars._cron_context = {\n\t\t\t\t\t\tjobId,\n\t\t\t\t\t\tscheduledTime: scheduledTime.toISOString(),\n\t\t\t\t\t\texecutionTime: executionTime.toISOString(),\n\t\t\t\t\t\tschedule: config.schedule,\n\t\t\t\t\t\ttimezone: config.timezone,\n\t\t\t\t\t\tmanual: String(manual),\n\t\t\t\t\t};\n\n\t\t\t\t\tctx.logger.log(`Executing cron job: ${jobId} (${manual ? \"manual\" : \"scheduled\"})`);\n\n\t\t\t\t\t// v0.6 · apply the merged middleware chain (process-global →\n\t\t\t\t\t// workflow-level → trigger-level) before the main workflow\n\t\t\t\t\t// body. Lets cron workflows compose auth-check + audit-log\n\t\t\t\t\t// chains exactly like HTTP triggers. A throwing middleware\n\t\t\t\t\t// propagates to the outer catch and surfaces as a cron job\n\t\t\t\t\t// failure.\n\t\t\t\t\tawait this.applyMiddlewareChain(ctx, this.nodeMap);\n\n\t\t\t\t\t// Execute workflow\n\t\t\t\t\tconst response: TriggerResponse = await this.run(ctx);\n\t\t\t\t\tconst end = performance.now();\n\n\t\t\t\t\t// Update job state\n\t\t\t\t\tscheduledJob.lastRun = executionTime;\n\t\t\t\t\tscheduledJob.nextRun = this.toDate(scheduledJob.job.nextDate());\n\n\t\t\t\t\t// Set span attributes\n\t\t\t\t\tspan.setAttribute(\"success\", true);\n\t\t\t\t\tspan.setAttribute(\"job_id\", jobId);\n\t\t\t\t\tspan.setAttribute(\"workflow_path\", workflow.path);\n\t\t\t\t\tspan.setAttribute(\"schedule\", config.schedule);\n\t\t\t\t\tspan.setAttribute(\"timezone\", timezone);\n\t\t\t\t\tspan.setAttribute(\"manual\", manual);\n\t\t\t\t\tspan.setAttribute(\"elapsed_ms\", end - start);\n\t\t\t\t\tspan.setStatus({ code: SpanStatusCode.OK });\n\n\t\t\t\t\t// Record metrics\n\t\t\t\t\tcronExecutions.add(1, {\n\t\t\t\t\t\tenv: process.env.NODE_ENV,\n\t\t\t\t\t\tjob_id: jobId,\n\t\t\t\t\t\tworkflow_name: this.configuration.name,\n\t\t\t\t\t\tmanual: String(manual),\n\t\t\t\t\t\tsuccess: \"true\",\n\t\t\t\t\t});\n\n\t\t\t\t\tctx.logger.log(`Cron job completed in ${(end - start).toFixed(2)}ms: ${jobId}`);\n\n\t\t\t\t\tresolve(response);\n\t\t\t\t} catch (error) {\n\t\t\t\t\t// F5 · a cron workflow with a `wait` step (or a scheduling\n\t\t\t\t\t// gate) throws DeferredDispatchSignal / WaitDispatchRequest\n\t\t\t\t\t// to defer the run — that's a successful deferral, NOT a\n\t\t\t\t\t// failure. TriggerBase.run already marked the run\n\t\t\t\t\t// delayed/queued/debounced and (for HTTP) persisted the\n\t\t\t\t\t// dispatch. Cron's in-process scheduler owns the eventual\n\t\t\t\t\t// re-fire, so we just record success and don't bump\n\t\t\t\t\t// `cron_errors`.\n\t\t\t\t\tif (error instanceof DeferredDispatchSignal || error instanceof WaitDispatchRequest) {\n\t\t\t\t\t\tspan.setAttribute(\"success\", true);\n\t\t\t\t\t\tspan.setAttribute(\"deferred\", true);\n\t\t\t\t\t\tspan.setStatus({ code: SpanStatusCode.OK });\n\n\t\t\t\t\t\tcronExecutions.add(1, {\n\t\t\t\t\t\t\tenv: process.env.NODE_ENV,\n\t\t\t\t\t\t\tjob_id: jobId,\n\t\t\t\t\t\t\tworkflow_name: this.configuration.name,\n\t\t\t\t\t\t\tmanual: String(manual),\n\t\t\t\t\t\t\tsuccess: \"true\",\n\t\t\t\t\t\t});\n\n\t\t\t\t\t\tthis.logger.log(`Cron job deferred ${jobId}: ${(error as Error).message}`);\n\t\t\t\t\t\tresolve({ ctx: {} as Context, metrics: {} as MetricsType });\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\tconst errorMessage = (error as Error).message;\n\n\t\t\t\t\t// Set span error\n\t\t\t\t\tspan.setAttribute(\"success\", false);\n\t\t\t\t\tspan.recordException(error as Error);\n\t\t\t\t\tspan.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });\n\n\t\t\t\t\t// Record error metrics\n\t\t\t\t\tcronErrors.add(1, {\n\t\t\t\t\t\tenv: process.env.NODE_ENV,\n\t\t\t\t\t\tjob_id: jobId,\n\t\t\t\t\t\tworkflow_name: this.configuration?.name || \"unknown\",\n\t\t\t\t\t\tmanual: String(manual),\n\t\t\t\t\t});\n\n\t\t\t\t\tthis.logger.error(`Cron job failed ${jobId}: ${errorMessage}`, (error as Error).stack);\n\n\t\t\t\t\tresolve({ ctx: {} as Context, metrics: {} as MetricsType });\n\t\t\t\t} finally {\n\t\t\t\t\tscheduledJob.running = false;\n\t\t\t\t\tspan.end();\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t}\n}\n\nexport default CronTrigger;\n"]}

package/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "@blokjs/trigger-cron",
-	"version": "0.6.17",
+	"version": "0.6.19",
+	"files": ["dist"],
 	"description": "Cron/scheduled trigger for Blok workflows - supports cron expressions and interval-based scheduling",
 	"type": "module",
 	"main": "dist/index.js",
@@ -14,9 +15,9 @@
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"dependencies": {
-		"@blokjs/helper": "^0.6.17",
-		"@blokjs/runner": "^0.6.17",
-		"@blokjs/shared": "^0.6.17",
+		"@blokjs/helper": "^0.6.19",
+		"@blokjs/runner": "^0.6.19",
+		"@blokjs/shared": "^0.6.19",
 		"@opentelemetry/api": "^1.9.0",
 		"cron": "^4.4.0",
 		"uuid": "^11.1.0"

package/CHANGELOG.md

@@ -1,22 +0,0 @@
-# @blokjs/trigger-cron
-
-## 0.2.0
-
-### Minor Changes
-
-- Initial public release of Blok packages.
-
-  This release includes:
-
-  - Core packages: @blokjs/shared, @blokjs/helper, @blokjs/runner
-  - Node packages: @blokjs/api-call, @blokjs/if-else, @blokjs/react
-  - Trigger packages: pubsub, queue, webhook, websocket, worker, cron, grpc
-  - CLI tool: blokctl
-  - Editor support: @blokjs/lsp-server, @blokjs/syntax
-
-### Patch Changes
-
-- Updated dependencies
-  - @blokjs/shared@0.2.0
-  - @blokjs/helper@0.2.0
-  - @blokjs/runner@0.2.0

package/src/CronTrigger.test.ts

@@ -1,119 +0,0 @@
-/**
- * CronTrigger Tests
- */
-
-import { describe, expect, it, vi } from "vitest";
-
-describe("CronTrigger", () => {
-	describe("ScheduledJob Interface", () => {
-		it("should accept valid scheduled job structure", () => {
-			const mockJob = {
-				nextDate: () => new Date(),
-				lastDate: () => new Date(),
-				start: vi.fn(),
-				stop: vi.fn(),
-			};
-
-			const scheduledJob = {
-				id: "cron-test-abc123",
-				workflowPath: "daily-cleanup",
-				schedule: "0 2 * * *",
-				timezone: "America/New_York",
-				overlap: false,
-				running: false,
-				lastRun: new Date(),
-				nextRun: new Date(),
-				job: mockJob,
-			};
-
-			expect(scheduledJob.id).toBe("cron-test-abc123");
-			expect(scheduledJob.schedule).toBe("0 2 * * *");
-			expect(scheduledJob.timezone).toBe("America/New_York");
-			expect(scheduledJob.overlap).toBe(false);
-		});
-	});
-
-	describe("CronExecutionContext Interface", () => {
-		it("should create valid execution context", () => {
-			const context = {
-				jobId: "cron-job-123",
-				scheduledTime: new Date("2024-01-01T02:00:00Z"),
-				executionTime: new Date("2024-01-01T02:00:01Z"),
-				schedule: "0 2 * * *",
-				timezone: "UTC",
-				manual: false,
-			};
-
-			expect(context.jobId).toBe("cron-job-123");
-			expect(context.scheduledTime.toISOString()).toBe("2024-01-01T02:00:00.000Z");
-			expect(context.manual).toBe(false);
-		});
-
-		it("should support manual trigger context", () => {
-			const context = {
-				jobId: "cron-job-456",
-				scheduledTime: new Date(),
-				executionTime: new Date(),
-				schedule: "0 * * * *",
-				timezone: "Europe/London",
-				manual: true,
-			};
-
-			expect(context.manual).toBe(true);
-		});
-	});
-
-	describe("CronTriggerOpts Schema", () => {
-		it("should validate cron trigger configuration", () => {
-			const validConfig = {
-				schedule: "0 * * * *",
-				timezone: "America/Los_Angeles",
-				overlap: false,
-			};
-
-			expect(validConfig.schedule).toBe("0 * * * *");
-			expect(validConfig.timezone).toBe("America/Los_Angeles");
-			expect(validConfig.overlap).toBe(false);
-		});
-
-		it("should support common cron expressions", () => {
-			const schedules = [
-				{ expr: "* * * * *", desc: "Every minute" },
-				{ expr: "0 * * * *", desc: "Every hour" },
-				{ expr: "0 0 * * *", desc: "Every day at midnight" },
-				{ expr: "0 0 * * 0", desc: "Every Sunday" },
-				{ expr: "0 0 1 * *", desc: "First day of month" },
-				{ expr: "*/5 * * * *", desc: "Every 5 minutes" },
-				{ expr: "0 9-17 * * 1-5", desc: "Hourly, 9-5 on weekdays" },
-			];
-
-			for (const schedule of schedules) {
-				expect(schedule.expr).toBeDefined();
-				expect(schedule.desc).toBeDefined();
-			}
-		});
-	});
-
-	describe("Timezone Support", () => {
-		it("should support common timezones", () => {
-			const timezones = [
-				"UTC",
-				"America/New_York",
-				"America/Los_Angeles",
-				"Europe/London",
-				"Europe/Paris",
-				"Asia/Tokyo",
-				"Australia/Sydney",
-			];
-
-			for (const tz of timezones) {
-				const config = {
-					schedule: "0 0 * * *",
-					timezone: tz,
-					overlap: false,
-				};
-				expect(config.timezone).toBe(tz);
-			}
-		});
-	});
-});

package/src/CronTrigger.ts

@@ -1,449 +0,0 @@
-/**
- * CronTrigger - Scheduled workflow execution based on cron expressions
- *
- * Extends TriggerBase to support scheduled triggers:
- * - Cron expressions (e.g., "0 * * * *" for hourly)
- * - Timezone-aware scheduling
- * - Overlap prevention
- * - Manual trigger support
- *
- * Uses the 'cron' package for cron parsing and scheduling.
- */
-
-import type { CronTriggerOpts, HelperResponse } from "@blokjs/helper";
-import {
-	type BlokService,
-	DefaultLogger,
-	type GlobalOptions,
-	NodeMap,
-	TriggerBase,
-	type TriggerResponse,
-} from "@blokjs/runner";
-import type { Context, MetricsType, RequestContext } from "@blokjs/shared";
-import { type Span, SpanStatusCode, metrics, trace } from "@opentelemetry/api";
-import { CronJob } from "cron";
-import { v4 as uuid } from "uuid";
-
-/**
- * Scheduled job information
- */
-export interface ScheduledJob {
-	/** Unique job ID */
-	id: string;
-	/** Workflow path */
-	workflowPath: string;
-	/** Cron expression */
-	schedule: string;
-	/** Timezone */
-	timezone: string;
-	/** Allow overlapping executions */
-	overlap: boolean;
-	/** Whether the job is currently running */
-	running: boolean;
-	/** Last execution time */
-	lastRun?: Date;
-	/** Next scheduled time */
-	nextRun?: Date;
-	/** Internal CronJob instance */
-	job: CronJob;
-}
-
-/**
- * Execution context passed to the workflow
- */
-export interface CronExecutionContext {
-	/** Job ID */
-	jobId: string;
-	/** Scheduled time (when it was supposed to run) */
-	scheduledTime: Date;
-	/** Actual execution time */
-	executionTime: Date;
-	/** Cron expression */
-	schedule: string;
-	/** Timezone */
-	timezone: string;
-	/** Whether this is a manual trigger */
-	manual: boolean;
-}
-
-/**
- * Workflow model with cron trigger configuration
- */
-interface CronWorkflowModel {
-	path: string;
-	config: {
-		name: string;
-		version: string;
-		trigger?: {
-			cron?: CronTriggerOpts;
-			[key: string]: unknown;
-		};
-		[key: string]: unknown;
-	};
-}
-
-/**
- * CronTrigger - Scheduled workflow execution
- */
-export abstract class CronTrigger extends TriggerBase {
-	protected nodeMap: GlobalOptions = {} as GlobalOptions;
-	protected readonly tracer = trace.getTracer(
-		process.env.PROJECT_NAME || "trigger-cron-workflow",
-		process.env.PROJECT_VERSION || "0.0.1",
-	);
-	protected readonly logger = new DefaultLogger();
-	protected jobs: Map<string, ScheduledJob> = new Map();
-
-	// Subclasses provide these
-	protected abstract nodes: Record<string, BlokService<unknown>>;
-	protected abstract workflows: Record<string, HelperResponse>;
-
-	constructor() {
-		super();
-		this.loadNodes();
-		this.loadWorkflows();
-	}
-
-	/**
-	 * Load nodes into the node map
-	 */
-	loadNodes(): void {
-		this.nodeMap.nodes = new NodeMap();
-		const nodeKeys = Object.keys(this.nodes);
-		for (const key of nodeKeys) {
-			this.nodeMap.nodes.addNode(key, this.nodes[key]);
-		}
-	}
-
-	/**
-	 * Load workflows into the workflow map
-	 */
-	loadWorkflows(): void {
-		this.nodeMap.workflows = this.workflows;
-	}
-
-	/**
-	 * Convert cron DateTime to Date
-	 * The cron package uses luxon DateTime which has toJSDate()
-	 */
-	protected toDate(dateTime: unknown): Date {
-		if (dateTime && typeof dateTime === "object" && "toJSDate" in dateTime) {
-			return (dateTime as { toJSDate: () => Date }).toJSDate();
-		}
-		return dateTime instanceof Date ? dateTime : new Date(dateTime as string | number);
-	}
-
-	/**
-	 * Start the cron scheduler - main entry point
-	 */
-	async listen(): Promise<number> {
-		const startTime = this.startCounter();
-
-		try {
-			// Find all workflows with cron triggers
-			const cronWorkflows = this.getCronWorkflows();
-
-			if (cronWorkflows.length === 0) {
-				this.logger.log("No workflows with cron triggers found");
-				return this.endCounter(startTime);
-			}
-
-			// Create and start cron jobs for each workflow
-			for (const workflow of cronWorkflows) {
-				const config = workflow.config.trigger?.cron as CronTriggerOpts;
-				const jobId = `cron-${workflow.path}-${uuid().slice(0, 8)}`;
-
-				// `CronTriggerOpts` is `z.input<…>` so `timezone` is `string | undefined`
-				// even though the schema declares `.default("UTC")`. Apply the
-				// default once here so the rest of this method (and the cron lib's
-				// constructor) sees a guaranteed string.
-				const timezone = config.timezone ?? "UTC";
-
-				this.logger.log(`Scheduling workflow: ${workflow.path} with schedule: ${config.schedule} (${timezone})`);
-
-				const job = new CronJob(
-					config.schedule,
-					async () => {
-						await this.executeWorkflow(jobId, workflow, config, false);
-					},
-					null, // onComplete
-					false, // start
-					timezone,
-				);
-
-				const scheduledJob: ScheduledJob = {
-					id: jobId,
-					workflowPath: workflow.path,
-					schedule: config.schedule,
-					timezone,
-					overlap: config.overlap ?? false,
-					running: false,
-					nextRun: this.toDate(job.nextDate()),
-					job,
-				};
-
-				this.jobs.set(jobId, scheduledJob);
-
-				// Start the job
-				job.start();
-				this.logger.log(`Job ${jobId} started. Next run: ${scheduledJob.nextRun}`);
-			}
-
-			this.logger.log(`Cron trigger started. ${this.jobs.size} job(s) scheduled`);
-
-			// Enable HMR in development mode
-			if (process.env.BLOK_HMR === "true" || process.env.NODE_ENV === "development") {
-				await this.enableHotReload();
-			}
-
-			return this.endCounter(startTime);
-		} catch (error) {
-			this.logger.error(`Failed to start cron trigger: ${(error as Error).message}`);
-			throw error;
-		}
-	}
-
-	/**
-	 * Stop all cron jobs
-	 */
-	async stop(): Promise<void> {
-		for (const [jobId, scheduledJob] of this.jobs) {
-			scheduledJob.job.stop();
-			this.logger.log(`Job ${jobId} stopped`);
-		}
-		this.jobs.clear();
-		this.logger.log("Cron trigger stopped");
-	}
-
-	protected override async onHmrWorkflowChange(): Promise<void> {
-		this.logger.log("[HMR] Cron workflow changed, reloading...");
-		await this.waitForInFlightRequests();
-		await this.stop();
-		this.loadWorkflows();
-		await this.listen();
-	}
-
-	/**
-	 * Manually trigger a specific job
-	 */
-	async triggerJob(jobId: string): Promise<TriggerResponse | null> {
-		const scheduledJob = this.jobs.get(jobId);
-		if (!scheduledJob) {
-			this.logger.error(`Job not found: ${jobId}`);
-			return null;
-		}
-
-		// Get the workflow
-		const workflow = this.getWorkflowByPath(scheduledJob.workflowPath);
-		if (!workflow) {
-			this.logger.error(`Workflow not found: ${scheduledJob.workflowPath}`);
-			return null;
-		}
-
-		const config = workflow.config.trigger?.cron as CronTriggerOpts;
-		return this.executeWorkflow(jobId, workflow, config, true);
-	}
-
-	/**
-	 * Get all scheduled jobs
-	 */
-	getJobs(): ScheduledJob[] {
-		return Array.from(this.jobs.values()).map((job) => ({
-			...job,
-			nextRun: this.toDate(job.job.nextDate()),
-		}));
-	}
-
-	/**
-	 * Get all workflows that have cron triggers
-	 */
-	protected getCronWorkflows(): CronWorkflowModel[] {
-		const workflows: CronWorkflowModel[] = [];
-
-		for (const [path, workflow] of Object.entries(this.nodeMap.workflows || {})) {
-			const workflowConfig = (workflow as unknown as { _config: CronWorkflowModel["config"] })._config;
-
-			if (workflowConfig?.trigger) {
-				const triggerType = Object.keys(workflowConfig.trigger)[0];
-
-				if (triggerType === "cron" && workflowConfig.trigger.cron) {
-					workflows.push({
-						path,
-						config: workflowConfig,
-					});
-				}
-			}
-		}
-
-		return workflows;
-	}
-
-	/**
-	 * Get workflow by path
-	 */
-	protected getWorkflowByPath(path: string): CronWorkflowModel | null {
-		const workflow = this.nodeMap.workflows?.[path];
-		if (!workflow) return null;
-
-		const workflowConfig = (workflow as unknown as { _config: CronWorkflowModel["config"] })._config;
-		return {
-			path,
-			config: workflowConfig,
-		};
-	}
-
-	/**
-	 * Execute a workflow
-	 */
-	protected async executeWorkflow(
-		jobId: string,
-		workflow: CronWorkflowModel,
-		config: CronTriggerOpts,
-		manual: boolean,
-	): Promise<TriggerResponse> {
-		const scheduledJob = this.jobs.get(jobId);
-		if (!scheduledJob) {
-			throw new Error(`Job not found: ${jobId}`);
-		}
-
-		// Check for overlap
-		if (scheduledJob.running && !scheduledJob.overlap) {
-			this.logger.log(`Skipping ${jobId}: previous execution still running (overlap disabled)`);
-			return { ctx: {} as Context, metrics: {} as MetricsType };
-		}
-
-		const executionId = uuid();
-		const lastDate = scheduledJob.job.lastDate();
-		const scheduledTime = lastDate ? new Date(lastDate as unknown as string | number) : new Date();
-		const executionTime = new Date();
-
-		// Apply the schema default — see explanation in `listen()`.
-		const timezone = config.timezone ?? "UTC";
-
-		const defaultMeter = metrics.getMeter("default");
-		const cronExecutions = defaultMeter.createCounter("cron_executions", {
-			description: "Cron job executions",
-		});
-		const cronErrors = defaultMeter.createCounter("cron_errors", {
-			description: "Cron job execution errors",
-		});
-
-		return new Promise((resolve) => {
-			this.tracer.startActiveSpan(`cron:${workflow.path}`, async (span: Span) => {
-				scheduledJob.running = true;
-
-				try {
-					const start = performance.now();
-
-					// Initialize configuration for this workflow
-					await this.configuration.init(workflow.path, this.nodeMap);
-
-					// Create context
-					const ctx: Context = this.createContext(undefined, workflow.path, executionId);
-
-					// Create execution context
-					const cronContext: CronExecutionContext = {
-						jobId,
-						scheduledTime,
-						executionTime,
-						schedule: config.schedule,
-						timezone,
-						manual,
-					};
-
-					// Populate request with cron context
-					ctx.request = {
-						body: cronContext,
-						headers: {
-							"x-cron-job-id": jobId,
-							"x-cron-schedule": config.schedule,
-							"x-cron-timezone": config.timezone,
-							"x-cron-manual": String(manual),
-						},
-						query: {},
-						params: {
-							jobId,
-							schedule: config.schedule,
-						},
-					} as unknown as RequestContext;
-
-					// Store cron context in vars
-					if (!ctx.vars) ctx.vars = {};
-					ctx.vars._cron_context = {
-						jobId,
-						scheduledTime: scheduledTime.toISOString(),
-						executionTime: executionTime.toISOString(),
-						schedule: config.schedule,
-						timezone: config.timezone,
-						manual: String(manual),
-					};
-
-					ctx.logger.log(`Executing cron job: ${jobId} (${manual ? "manual" : "scheduled"})`);
-
-					// v0.6 · apply the merged middleware chain (process-global →
-					// workflow-level → trigger-level) before the main workflow
-					// body. Lets cron workflows compose auth-check + audit-log
-					// chains exactly like HTTP triggers. A throwing middleware
-					// propagates to the outer catch and surfaces as a cron job
-					// failure.
-					await this.applyMiddlewareChain(ctx, this.nodeMap);
-
-					// Execute workflow
-					const response: TriggerResponse = await this.run(ctx);
-					const end = performance.now();
-
-					// Update job state
-					scheduledJob.lastRun = executionTime;
-					scheduledJob.nextRun = this.toDate(scheduledJob.job.nextDate());
-
-					// Set span attributes
-					span.setAttribute("success", true);
-					span.setAttribute("job_id", jobId);
-					span.setAttribute("workflow_path", workflow.path);
-					span.setAttribute("schedule", config.schedule);
-					span.setAttribute("timezone", timezone);
-					span.setAttribute("manual", manual);
-					span.setAttribute("elapsed_ms", end - start);
-					span.setStatus({ code: SpanStatusCode.OK });
-
-					// Record metrics
-					cronExecutions.add(1, {
-						env: process.env.NODE_ENV,
-						job_id: jobId,
-						workflow_name: this.configuration.name,
-						manual: String(manual),
-						success: "true",
-					});
-
-					ctx.logger.log(`Cron job completed in ${(end - start).toFixed(2)}ms: ${jobId}`);
-
-					resolve(response);
-				} catch (error) {
-					const errorMessage = (error as Error).message;
-
-					// Set span error
-					span.setAttribute("success", false);
-					span.recordException(error as Error);
-					span.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
-
-					// Record error metrics
-					cronErrors.add(1, {
-						env: process.env.NODE_ENV,
-						job_id: jobId,
-						workflow_name: this.configuration?.name || "unknown",
-						manual: String(manual),
-					});
-
-					this.logger.error(`Cron job failed ${jobId}: ${errorMessage}`, (error as Error).stack);
-
-					resolve({ ctx: {} as Context, metrics: {} as MetricsType });
-				} finally {
-					scheduledJob.running = false;
-					span.end();
-				}
-			});
-		});
-	}
-}
-
-export default CronTrigger;

package/src/index.ts

@@ -1,72 +0,0 @@
-/**
- * @blokjs/trigger-cron
- *
- * Cron/scheduled trigger for Blok workflows.
- * Execute workflows on a schedule using cron expressions.
- *
- * Features:
- * - Standard cron expression syntax
- * - Timezone-aware scheduling
- * - Overlap prevention
- * - Manual trigger support
- * - Job management API
- *
- * @example
- * ```typescript
- * import { CronTrigger } from "@blokjs/trigger-cron";
- *
- * class MyCronTrigger extends CronTrigger {
- *   protected nodes = myNodes;
- *   protected workflows = myWorkflows;
- * }
- *
- * const trigger = new MyCronTrigger();
- * await trigger.listen();
- *
- * // List all scheduled jobs
- * const jobs = trigger.getJobs();
- *
- * // Manually trigger a job
- * await trigger.triggerJob("cron-my-workflow-abc123");
- * ```
- *
- * Workflow Definition:
- * ```typescript
- * Workflow({ name: "daily-cleanup", version: "1.0.0" })
- *   .addTrigger("cron", {
- *     schedule: "0 2 * * *",  // Run at 2 AM daily
- *     timezone: "America/New_York",
- *     overlap: false,
- *   })
- *   .addStep({ ... });
- * ```
- *
- * Cron Expression Format:
- * ```
- * * * * * * *
- * │ │ │ │ │ │
- * │ │ │ │ │ └── Day of week (0-7, Sun=0,7)
- * │ │ │ │ └──── Month (1-12)
- * │ │ │ └────── Day of month (1-31)
- * │ │ └──────── Hour (0-23)
- * │ └────────── Minute (0-59)
- * └──────────── Second (0-59, optional)
- * ```
- *
- * Common schedules:
- * - "* * * * *" - Every minute
- * - "0 * * * *" - Every hour
- * - "0 0 * * *" - Every day at midnight
- * - "0 0 * * 0" - Every Sunday at midnight
- * - "0 0 1 * *" - First day of every month
- */
-
-// Core exports
-export {
-	CronTrigger,
-	type ScheduledJob,
-	type CronExecutionContext,
-} from "./CronTrigger";
-
-// Re-export types from helper for convenience
-export type { CronTriggerOpts } from "@blokjs/helper";

package/tsconfig.json

@@ -1,32 +0,0 @@
-{
-	"ts-node": {
-		"transpileOnly": true
-	},
-	"compilerOptions": {
-		"target": "ES2022",
-		"module": "es2022",
-		"lib": ["ES2022"],
-		"declaration": true,
-		"strict": true,
-		"noImplicitAny": true,
-		"strictNullChecks": true,
-		"noImplicitThis": true,
-		"alwaysStrict": true,
-		"noUnusedLocals": false,
-		"noUnusedParameters": false,
-		"noImplicitReturns": true,
-		"noFallthroughCasesInSwitch": false,
-		"inlineSourceMap": true,
-		"inlineSources": true,
-		"experimentalDecorators": true,
-		"emitDecoratorMetadata": true,
-		"skipLibCheck": true,
-		"esModuleInterop": true,
-		"resolveJsonModule": true,
-		"outDir": "./dist",
-		"rootDir": "./src",
-		"moduleResolution": "bundler"
-	},
-	"include": ["src/**/*"],
-	"exclude": ["node_modules", "dist", "**/*.test.ts"]
-}