workflow-cron-sleep 1.0.0 → 1.0.2

package/README.md

@@ -88,16 +88,16 @@ Throws an error if the cron expression is invalid or has no future occurrences.
 
 Since `cronSleep` only sleeps until the **next** occurrence, you need to design your workflow architecture to handle recurring schedules.
 
-### Pattern: Separate Scheduler and Processor Workflows
+### Pattern: While Loop Scheduler
 
-Separate your scheduling logic from your business logic by keeping workflows and steps in different files:
+The simplest approach is a single workflow with a `while (true)` loop that sleeps and triggers your business logic workflow repeatedly:
 
 **`workflows/report-scheduler.ts`** - The scheduler workflow
 ```typescript
 import { cronSleep } from "workflow-cron-sleep"
-import { startReportProcessor } from "./steps"
+import { triggerReportProcessor } from "./steps"
 
-interface ReportSchedulerInput {
+export interface ReportSchedulerInput {
     reportId: string
     cronExpression: string
 }
@@ -107,26 +107,65 @@ export async function reportScheduler(input: ReportSchedulerInput) {
     
     const { reportId, cronExpression } = input
     
-    // Wait for the next scheduled time
-    await cronSleep(cronExpression, { timezone: "America/New_York" })
-    
-    // Trigger the processor workflow
-    await startReportProcessor(reportId)
+    while (true) {
+        // Wait for the next scheduled time
+        await cronSleep(cronExpression, { timezone: "America/New_York" })
+        
+        // Trigger the processor workflow
+        await triggerReportProcessor(reportId)
+    }
 }
 ```
 
-**`workflows/steps.ts`** - Step functions in a separate file
+**`workflows/steps.ts`** - Step function to start the processor
 ```typescript
-import { start } from "workflow"
+import { start } from "workflow/api"
 import { reportProcessorWorkflow } from "./report-processor"
 
-export async function startReportProcessor(reportId: string) {
+export async function triggerReportProcessor(reportId: string) {
     "use step"
     await start(reportProcessorWorkflow, [{ reportId }])
 }
 ```
 
-This pattern keeps your scheduling and business logic decoupled, making each workflow easier to test and maintain.
+**`workflows/report-processor.ts`** - The processor workflow (business logic)
+```typescript
+export interface ReportProcessorInput {
+    reportId: string
+}
+
+export async function reportProcessorWorkflow(input: ReportProcessorInput) {
+    "use workflow"
+    
+    const { reportId } = input
+    
+    // Your business logic here - completely agnostic to scheduling
+    await generateReport(reportId)
+    await sendNotifications(reportId)
+}
+```
+
+### Starting and Canceling
+
+```typescript
+import { start, getRun } from "workflow/api"
+import { reportScheduler } from "./workflows/report-scheduler"
+
+// Start the cron scheduler
+const run = await start(reportScheduler, [{
+    reportId: "daily-report",
+    cronExpression: "0 9 * * *"
+}])
+
+// Save the run ID to cancel later
+await db.cronJobs.create({ runId: run.id })
+
+// To cancel the cron (stops the while loop)
+const currentRun = getRun(run.id)
+await currentRun.cancel()
+```
+
+This pattern keeps your scheduling and business logic decoupled. The scheduler runs forever, triggering your processor workflow on schedule. Save the `runId` so you can cancel if the cron expression changes or the job is no longer needed.
 
 ## Requirements
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "workflow-cron-sleep",
-    "version": "1.0.0",
+    "version": "1.0.2",
     "description": "Sleep until the next cron expression occurrence in Vercel Workflows",
     "type": "module",
     "main": "dist/index.js",
@@ -40,4 +40,4 @@
         "typescript": "^5.3.0",
         "workflow": "^4.0.1-beta.44"
     }
-}
+}