@stacksjs/scheduler 0.68.2 → 0.69.2

package/dist/run.d.ts

@@ -0,0 +1,7 @@
+import type { Err } from '@stacksjs/error-handling';
+import type { JobOptions } from '@stacksjs/types';
+
+export declare function runScheduler(): Promise<Ok<string, never> | Err<string, any>>;
+declare function runSchedulerInstance(): Promise<void>;
+declare function executeJobRate(jobName: string, rate: string): void;
+declare function getJobName(job: JobOptions, jobPath: string): string;

package/dist/schedule.d.ts

@@ -1,131 +1,239 @@
-import type { DateTime } from 'luxon';
+import type { CatchCallbackFn, CronOptions } from '@stacksjs/cron';
+import type { TimedSchedule, Timezone, UntimedSchedule } from './types';
 
-export declare class Schedule {
+export declare class Schedule implements UntimedSchedule {
+  private static jobs = new Map<string, Cron>()
   private cronPattern = ''
-  private timezone = 'America/Los_Angeles'
+  private timezone: Timezone = 'America/Los_Angeles'
   private readonly task: () => void
+  private options: {
+    timezone?: string
+    catch?: CatchCallbackFn
+    maxRuns?: number
+    protect?: boolean | ((job: Cron) => void)
+    name?: string
+    context?: any
+    interval?: number
+    startAt?: string | Date
+    stopAt?: string | Date
+  } = {}
 
   constructor(task: () => void) {
     this.task = task
+    setTimeout(() => this.start(), 0)
   }
 
-  everySecond(): Schedule {
+  everySecond(): TimedSchedule {
     this.cronPattern = '* * * * * *'
-    return this
+    return this as TimedSchedule
   }
 
-  everyMinute(): Schedule {
+  everyMinute(): TimedSchedule {
     this.cronPattern = '0 * * * * *'
-    return this
+    return this as TimedSchedule
   }
 
-  everyTwoMinutes(): Schedule {
+  everyTwoMinutes(): TimedSchedule {
     this.cronPattern = '*/2 * * * * *'
-    return this
+    return this as TimedSchedule
   }
 
-  everyFiveMinutes(): Schedule {
+  everyFiveMinutes(): TimedSchedule {
     this.cronPattern = '*/5 * * * *'
-    return this
+    return this as TimedSchedule
   }
 
-  everyTenMinutes(): Schedule {
+  everyTenMinutes(): TimedSchedule {
     this.cronPattern = '*/10 * * * *'
-    return this
+    return this as TimedSchedule
   }
 
-  everyThirtyMinutes(): Schedule {
+  everyThirtyMinutes(): TimedSchedule {
     this.cronPattern = '*/30 * * * *'
-    return this
+    return this as TimedSchedule
   }
 
-  everyHour(): Schedule {
+  everyHour(): TimedSchedule {
     this.cronPattern = '0 0 * * * *'
-    return this
+    return this as TimedSchedule
   }
 
-  everyDay(): Schedule {
+  everyDay(): TimedSchedule {
     this.cronPattern = '0 0 0 * * *'
-    return this
+    return this as TimedSchedule
   }
 
-  hourly(): Schedule {
+  hourly(): TimedSchedule {
     this.cronPattern = '0 0 * * * *'
-    return this
+    return this as TimedSchedule
   }
 
-  daily(): Schedule {
+  daily(): TimedSchedule {
     this.cronPattern = '0 0 0 * * *'
-    return this
+    return this as TimedSchedule
   }
 
-  weekly(): Schedule {
+  weekly(): TimedSchedule {
     this.cronPattern = '0 0 0 * * 0'
-    return this
+    return this as TimedSchedule
   }
 
-  monthly(): Schedule {
+  monthly(): TimedSchedule {
     this.cronPattern = '0 0 0 1 * *'
-    return this
+    return this as TimedSchedule
   }
 
-  yearly(): Schedule {
+  yearly(): TimedSchedule {
     this.cronPattern = '0 0 0 1 1 *'
-    return this
+    return this as TimedSchedule
   }
 
-  onDays(days: number[]): Schedule {
+  annually(): TimedSchedule {
+    this.cronPattern = '0 0 0 1 1 *'
+    return this as TimedSchedule
+  }
+
+  onDays(days: number[]): TimedSchedule {
     const dayPattern = days.join(',')
     this.cronPattern = `0 0 0 * * ${dayPattern}`
-    return this
+    return this as TimedSchedule
   }
 
-
-  at(time: string): Schedule {
+  at(time: string): TimedSchedule {
     const [hour, minute] = time.split(':').map(Number)
     this.cronPattern = `${minute} ${hour} * * *`
-    return this
+    return this as TimedSchedule
   }
 
-  setTimeZone(timezone: string): Schedule {
+  setTimeZone(timezone: Timezone): this {
     this.timezone = timezone
+    this.options.timezone = timezone
     return this
   }
 
-  start(): void {
-    new CronJob(this.cronPattern, this.task, null, true, this.timezone)
-    log.info(`Scheduled task with pattern: ${this.cronPattern} in timezone: ${this.timezone}`)
+  withErrorHandler(handler: CatchCallbackFn): this {
+    this.options.catch = handler
+    return this
+  }
+
+  withMaxRuns(runs: number): this {
+    this.options.maxRuns = runs
+    return this
+  }
+
+  withProtection(callback?: (job: Cron) => void): this {
+    this.options.protect = callback || true
+    return this
+  }
+
+  withName(name: string): this {
+    this.options.name = name
+    return this
+  }
+
+  withContext(context: any): this {
+    this.options.context = context
+    return this
   }
 
-  job(path: string): Schedule {
-    log.info(`Scheduling job: ${path}`)
+  withInterval(seconds: number): this {
+    this.options.interval = seconds
     return this
   }
 
-  action(path: string): Schedule {
-    log.info(`Scheduling action: ${path}`)
+  between(startAt: string | Date, stopAt: string | Date): this {
+    this.options.startAt = startAt
+    this.options.stopAt = stopAt
     return this
   }
 
-  static command(cmd: string): Schedule {
-    log.info(`Executing command: ${cmd}`)
+  private start(): Cron {
+    const job = new Cron(
+      this.cronPattern,
+      {
+        ...this.options,
+        timezone: this.timezone,
+      } as CronOptions,
+      this.task,
+    )
+
+    if (this.options.name) {
+      Schedule.jobs.set(this.options.name, job)
+    }
+
+    log.info(`Scheduled task with pattern: ${this.cronPattern} in timezone: ${this.timezone}`)
+    return job
+  }
+
+  static job(name: string): UntimedSchedule {
     return new Schedule(async () => {
-      log.info(`Executing command: ${cmd}`)
+      log.info(`Running job: ${name}`)
+      try {
+        await runJob(name)
+      }
+      catch (error) {
+        log.error(`Job ${name} failed:`, error)
+        throw error 
+      }
+    }).withName(name) as UntimedSchedule
+  }
 
-      const result = await runCommand(cmd)
+  static action(name: string): UntimedSchedule {
+    return new Schedule(async () => {
+      log.info(`Running action: ${name}`)
+      try {
+        await runAction(name)
+      }
+      catch (error) {
+        log.error(`Action ${name} failed:`, error)
+        throw error
+      }
+    }).withName(name) as UntimedSchedule
+  }
 
-      if (result.isErr()) {
-        log.error(result.error)
-        return
+  static command(cmd: string): UntimedSchedule {
+    return new Schedule(async () => {
+      try {
+        log.info(`Executing command: ${cmd}`)
+        const result = await runCommand(cmd)
+
+        if (result.isErr()) {
+          log.error(result.error)
+          throw result.error
+        }
       }
+      catch (error) {
+        log.error(`Command execution failed: ${error}`)
+        throw error
+      }
+    }).withName(`command-${cmd}`) as UntimedSchedule
+  }
+
+  static async gracefulShutdown(): Promise<void> {
+    log.info('Gracefully shutting down scheduled jobs...')
+
+    const shutdownPromises = []
+
+    for (const [name, job] of Schedule.jobs) {
+      log.info(`Stopping job: ${name}`)
+      shutdownPromises.push(
+        new Promise<void>((resolve) => {
+          job.stop()
+          resolve()
+        }),
+      )
+    }
+
+    await Promise.all(shutdownPromises)
+    Schedule.jobs.clear()
 
-      log.info(result.value)
-    })
+    log.info('All jobs have been stopped')
   }
 }
-export declare class Job extends Schedule {}
-export declare function sendAt(cronTime: string | Date | DateTime): DateTime;
-export declare function timeout(cronTime: string | Date | DateTime): number;
+export declare class Job extends Schedule { }
+export declare function sendAt(cronTime: string | Date): Date | null;
+export declare function timeout(cronTime: string | Date): number;
 export declare type Scheduler = typeof Schedule
+export const schedule: Scheduler = Schedule
 
-export default Schedule;
+export default Schedule

package/dist/types.d.ts

@@ -1,3 +1,101 @@
-export declare type IntRange<Min extends number, Max extends number> = number extends Min | Max
-  ? never
-  : number | [Min | number, Max | number]
+import type { CatchCallbackFn, Cron } from '@stacksjs/cron';
+
+export declare type Timezone =
+  | 'Africa/Abidjan'
+  | 'Africa/Accra'
+  | 'Africa/Addis_Ababa'
+  | 'Africa/Algiers'
+  | 'Africa/Cairo'
+  | 'Africa/Casablanca'
+  | 'Africa/Lagos'
+  | 'Africa/Nairobi'
+  | 'America/Anchorage'
+  | 'America/Argentina/Buenos_Aires'
+  | 'America/Bogota'
+  | 'America/Caracas'
+  | 'America/Chicago'
+  | 'America/Denver'
+  | 'America/Detroit'
+  | 'America/Halifax'
+  | 'America/Los_Angeles'
+  | 'America/Mexico_City'
+  | 'America/New_York'
+  | 'America/Phoenix'
+  | 'America/Santiago'
+  | 'America/Sao_Paulo'
+  | 'America/Toronto'
+  | 'America/Vancouver'
+  | 'Asia/Bangkok'
+  | 'Asia/Dubai'
+  | 'Asia/Hong_Kong'
+  | 'Asia/Istanbul'
+  | 'Asia/Jakarta'
+  | 'Asia/Jerusalem'
+  | 'Asia/Karachi'
+  | 'Asia/Kolkata'
+  | 'Asia/Kuwait'
+  | 'Asia/Manila'
+  | 'Asia/Shanghai'
+  | 'Asia/Singapore'
+  | 'Asia/Tokyo'
+  | 'Australia/Melbourne'
+  | 'Australia/Perth'
+  | 'Australia/Sydney'
+  | 'Europe/Amsterdam'
+  | 'Europe/Athens'
+  | 'Europe/Belgrade'
+  | 'Europe/Berlin'
+  | 'Europe/Brussels'
+  | 'Europe/Budapest'
+  | 'Europe/Copenhagen'
+  | 'Europe/Dublin'
+  | 'Europe/Helsinki'
+  | 'Europe/Istanbul'
+  | 'Europe/Lisbon'
+  | 'Europe/London'
+  | 'Europe/Madrid'
+  | 'Europe/Moscow'
+  | 'Europe/Paris'
+  | 'Europe/Prague'
+  | 'Europe/Rome'
+  | 'Europe/Stockholm'
+  | 'Europe/Vienna'
+  | 'Europe/Warsaw'
+  | 'Europe/Zurich'
+  | 'Pacific/Auckland'
+  | 'Pacific/Fiji'
+  | 'Pacific/Honolulu'
+  | 'UTC'
+
+export interface BaseSchedule {
+  withErrorHandler: (handler: CatchCallbackFn) => this
+  withMaxRuns: (runs: number) => this
+  withProtection: (callback?: (job: Cron) => void) => this
+  withName: (name: string) => this
+  withContext: (context: any) => this
+  withInterval: (seconds: number) => this
+  between: (startAt: string | Date, stopAt: string | Date) => this
+  setTimeZone: (timezone: Timezone) => this
+}
+
+export interface TimedSchedule extends BaseSchedule {
+}
+
+export interface UntimedSchedule extends BaseSchedule {
+  everySecond: () => TimedSchedule
+  everyMinute: () => TimedSchedule
+  everyTwoMinutes: () => TimedSchedule
+  everyFiveMinutes: () => TimedSchedule
+  everyTenMinutes: () => TimedSchedule
+  everyThirtyMinutes: () => TimedSchedule
+  everyHour: () => TimedSchedule
+  everyDay: () => TimedSchedule
+  hourly: () => TimedSchedule
+  daily: () => TimedSchedule
+  weekly: () => TimedSchedule
+  monthly: () => TimedSchedule
+  yearly: () => TimedSchedule
+  annually: () => TimedSchedule
+  onDays: (days: number[]) => TimedSchedule
+  at: (time: string) => TimedSchedule
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/scheduler",
   "type": "module",
-  "version": "0.68.2",
+  "version": "0.69.2",
   "description": "The Stacks scheduler.",
   "author": "Chris Breuer",
   "contributors": ["Chris Breuer <chris@stacksjs.org>"],
@@ -33,10 +33,9 @@
     "typecheck": "bun tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
-  "dependencies": {
-    "cron": "^3.1.7"
-  },
   "devDependencies": {
-    "@stacksjs/development": "0.68.1"
+    "@stacksjs/actions": "0.69.2",
+    "@stacksjs/cron": "0.69.2",
+    "@stacksjs/development": "0.69.2"
   }
 }

package/dist/cron.d.ts

@@ -1,2 +0,0 @@
-export type {;
-export { CronJob, CronTime } from 'cron'