@stacksjs/scheduler 0.64.5 → 0.65.0

package/dist/schedule.d.ts

@@ -0,0 +1,32 @@
+import type { DateTime } from "luxon";
+export declare class Schedule {
+	private cronPattern;
+	private timezone;
+	private readonly task;
+	constructor(task: () => void);
+	everySecond(): Schedule;
+	everyMinute(): Schedule;
+	everyTwoMinutes(): Schedule;
+	everyFiveMinutes(): Schedule;
+	everyTenMinutes(): Schedule;
+	everyThirtyMinutes(): Schedule;
+	everyHour(): Schedule;
+	everyDay(): Schedule;
+	hourly(): Schedule;
+	daily(): Schedule;
+	weekly(): Schedule;
+	monthly(): Schedule;
+	yearly(): Schedule;
+	onDays(days: number[]): Schedule;
+	at(time: string): Schedule;
+	setTimeZone(timezone: string): Schedule;
+	start(): void;
+	job(path: string): Schedule;
+	action(path: string): Schedule;
+	static command(cmd: string): Schedule;
+}
+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 type Scheduler = typeof Schedule;
+export default Schedule;

package/dist/types.d.ts

@@ -0,0 +1,4 @@
+export type IntRange<
+	Min extends number,
+	Max extends number
+> = number extends Min | Max ? never : number | [Min | number, Max | number];

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@stacksjs/scheduler",
   "type": "module",
-  "version": "0.64.5",
+  "version": "0.65.0",
   "description": "The Stacks scheduler.",
   "author": "Chris Breuer",
+  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/scheduler#readme",
@@ -15,13 +16,7 @@
   "bugs": {
     "url": "https://github.com/stacksjs/stacks/issues"
   },
-  "keywords": [
-    "scheduler",
-    "node-cron",
-    "jobs",
-    "bun",
-    "stacks"
-  ],
+  "keywords": ["scheduler", "node-cron", "jobs", "bun", "stacks"],
   "exports": {
     ".": {
       "bun": "./src/index.ts",
@@ -34,27 +29,16 @@
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "contributors": [
-    "Chris Breuer <chris@stacksjs.org>"
-  ],
-  "files": [
-    "README.md",
-    "dist",
-    "src"
-  ],
+  "files": ["README.md", "dist", "src"],
   "scripts": {
-    "build": "bun --bun build.ts",
-    "typecheck": "bun --bun tsc --noEmit",
+    "build": "bun build.ts",
+    "typecheck": "bun tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "luxon": "^3.5.0"
+    "cron": "^3.1.7"
   },
   "devDependencies": {
-    "@fast-check/jest": "^2.0.2",
-    "@stacksjs/development": "latest",
-    "@types/luxon": "^3.4.2",
-    "@types/sinon": "^17.0.3",
-    "sinon": "^18.0.0"
+    "@stacksjs/development": "0.64.6"
   }
 }

package/src/cron.ts

@@ -0,0 +1,11 @@
+export type {
+  CronCallback,
+  CronCommand,
+  CronContext,
+  CronJobParams,
+  CronOnCompleteCallback,
+  CronOnCompleteCommand,
+  Ranges,
+  TimeUnit,
+} from 'cron'
+export { CronJob, CronTime } from 'cron'

package/src/index.ts

@@ -1,20 +1,7 @@
-export { Schedule } from './schedule'
+// export { Schedule } from './schedule'
 
-export { CronJob as BunCronJob } from './job'
-export { CronTime } from './time'
-
-export type {
-  CronCallback,
-  CronCommand,
-  CronContext,
-  CronJobParams,
-  CronOnCompleteCallback,
-  CronOnCompleteCommand,
-  Ranges,
-  TimeUnit,
-} from './types/cron'
-
-export * from './types/utils'
+export * from './cron'
 export * from './schedule'
+export * from './types'
 
 // export default Schedule

package/src/schedule.ts

@@ -1,7 +1,6 @@
-import { log } from '@stacksjs/cli'
 import type { DateTime } from 'luxon'
-import { CronJob } from './job'
-import { CronTime } from './time'
+import { log, runCommand } from '@stacksjs/cli'
+import { CronJob, CronTime } from './'
 
 export class Schedule {
   private cronPattern = ''
@@ -13,62 +12,72 @@ export class Schedule {
     this.task = task
   }
 
-  everySecond() {
+  everySecond(): Schedule {
     this.cronPattern = '* * * * * *'
     return this
   }
 
-  everyMinute() {
+  everyMinute(): Schedule {
     this.cronPattern = '0 * * * * *'
     return this
   }
 
-  everyTwoMinutes() {
+  everyTwoMinutes(): Schedule {
     this.cronPattern = '*/2 * * * * *'
     return this
   }
 
-  everyFiveMinutes() {
+  everyFiveMinutes(): Schedule {
     this.cronPattern = '*/5 * * * *'
     return this
   }
 
-  everyTenMinutes() {
+  everyTenMinutes(): Schedule {
     this.cronPattern = '*/10 * * * *'
     return this
   }
 
-  everyThirtyMinutes() {
+  everyThirtyMinutes(): Schedule {
     this.cronPattern = '*/30 * * * *'
     return this
   }
 
-  hourly() {
+  everyHour(): Schedule {
     this.cronPattern = '0 0 * * * *'
     return this
   }
 
-  daily() {
+  everyDay(): Schedule {
     this.cronPattern = '0 0 0 * * *'
     return this
   }
 
-  weekly() {
+  hourly(): Schedule {
+    this.cronPattern = '0 0 * * * *'
+    return this
+  }
+
+  daily(): Schedule {
+    this.cronPattern = '0 0 0 * * *'
+    return this
+  }
+
+  weekly(): Schedule {
     this.cronPattern = '0 0 0 * * 0'
     return this
   }
 
-  monthly() {
+  monthly(): Schedule {
     this.cronPattern = '0 0 0 1 * *'
     return this
   }
 
-  yearly() {
+  yearly(): Schedule {
     this.cronPattern = '0 0 0 1 1 *'
     return this
   }
 
-  onDays(days: number[]) {
+  onDays(days: number[]): Schedule {
     const dayPattern = days.join(',')
     this.cronPattern = `0 0 0 * * ${dayPattern}`
     return this
@@ -81,41 +90,54 @@ export class Schedule {
   //   return this
   // }
 
-  at(time: string) {
+  at(time: string): Schedule {
     // Assuming time is in "HH:MM" format
     const [hour, minute] = time.split(':').map(Number)
     this.cronPattern = `${minute} ${hour} * * *`
     return this
   }
 
-  setTimeZone(timezone: string) {
+  setTimeZone(timezone: string): Schedule {
     this.timezone = timezone
     return this
   }
 
-  start() {
+  start(): void {
+    // eslint-disable-next-line no-new
     new CronJob(this.cronPattern, this.task, null, true, this.timezone)
     log.info(`Scheduled task with pattern: ${this.cronPattern} in timezone: ${this.timezone}`)
   }
 
   // job and action methods need to be added and they accept a path string param
-  job(path: string) {
+  job(path: string): Schedule {
     log.info(`Scheduling job: ${path}`)
     return this
   }
 
-  action(path: string) {
+  action(path: string): Schedule {
     log.info(`Scheduling action: ${path}`)
     return this
   }
 
-  static command(cmd: string) {
+  static command(cmd: string): Schedule {
     log.info(`Executing command: ${cmd}`)
-    // this.cmd = cmd
-    return this
+    return new Schedule(async () => {
+      log.info(`Executing command: ${cmd}`)
+
+      const result = await runCommand(cmd)
+
+      if (result.isErr()) {
+        log.error(result.error)
+        return
+      }
+
+      log.info(result.value)
+    })
   }
 }
 
+export class Job extends Schedule {}
+
 export function sendAt(cronTime: string | Date | DateTime): DateTime {
   return new CronTime(cronTime).sendAt()
 }

package/src/types.ts

@@ -0,0 +1,3 @@
+export type IntRange<Min extends number, Max extends number> = number extends Min | Max
+  ? never
+  : number | [Min | number, Max | number]

package/src/constants.ts

@@ -1,81 +0,0 @@
-export const CONSTRAINTS = Object.freeze({
-  second: [0, 59],
-  minute: [0, 59],
-  hour: [0, 23],
-  dayOfMonth: [1, 31],
-  month: [1, 12],
-  dayOfWeek: [0, 7],
-} as const)
-export const MONTH_CONSTRAINTS = Object.freeze({
-  1: 31,
-  2: 29, // support leap year...not perfect
-  3: 31,
-  4: 30,
-  5: 31,
-  6: 30,
-  7: 31,
-  8: 31,
-  9: 30,
-  10: 31,
-  11: 30,
-  12: 31,
-} as const)
-export const PARSE_DEFAULTS = Object.freeze({
-  second: '0',
-  minute: '*',
-  hour: '*',
-  dayOfMonth: '*',
-  month: '*',
-  dayOfWeek: '*',
-} as const)
-export const ALIASES = Object.freeze({
-  jan: 1,
-  feb: 2,
-  mar: 3,
-  apr: 4,
-  may: 5,
-  jun: 6,
-  jul: 7,
-  aug: 8,
-  sep: 9,
-  oct: 10,
-  nov: 11,
-  dec: 12,
-  sun: 0,
-  mon: 1,
-  tue: 2,
-  wed: 3,
-  thu: 4,
-  fri: 5,
-  sat: 6,
-} as const)
-export const TIME_UNITS_MAP = Object.freeze({
-  SECOND: 'second',
-  MINUTE: 'minute',
-  HOUR: 'hour',
-  DAY_OF_MONTH: 'dayOfMonth',
-  MONTH: 'month',
-  DAY_OF_WEEK: 'dayOfWeek',
-} as const)
-export const TIME_UNITS = Object.freeze(Object.values(TIME_UNITS_MAP)) as [
-  'second',
-  'minute',
-  'hour',
-  'dayOfMonth',
-  'month',
-  'dayOfWeek',
-]
-export const TIME_UNITS_LEN: number = TIME_UNITS.length
-export const PRESETS = Object.freeze({
-  '@yearly': '0 0 0 1 1 *',
-  '@monthly': '0 0 0 1 * *',
-  '@weekly': '0 0 0 * * 0',
-  '@daily': '0 0 0 * * *',
-  '@hourly': '0 0 * * * *',
-  '@minutely': '0 * * * * *',
-  '@secondly': '* * * * * *',
-  '@weekdays': '0 0 0 * * 1-5',
-  '@weekends': '0 0 0 * * 0,6',
-} as const)
-export const RE_WILDCARDS = /\*/g
-export const RE_RANGE = /^(\d+)(?:-(\d+))?(?:\/(\d+))?$/g

package/src/errors.ts

@@ -1,7 +0,0 @@
-export class CronError extends Error {}
-
-export class ExclusiveParametersError extends CronError {
-  constructor(param1: string, param2: string) {
-    super(`You can't specify both ${param1} and ${param2}`)
-  }
-}

package/src/job.ts

@@ -1,280 +0,0 @@
-/**
- * Many thanks to https://github.com/kelektiv/node-cron for the inspiration
- */
-
-import { spawn } from 'node:child_process'
-import { CronError, ExclusiveParametersError } from './errors'
-import { CronTime } from './time'
-import type {
-  CronCallback,
-  CronCommand,
-  CronContext,
-  CronJobParams,
-  CronOnCompleteCallback,
-  CronOnCompleteCommand,
-  WithOnComplete,
-} from './types/cron'
-import { getTimeZoneAndOffset } from './utils'
-
-export class CronJob<OC extends CronOnCompleteCommand | null = null, C = null> {
-  cronTime: CronTime
-  running = false
-  unrefTimeout = false
-  lastExecution: Date | null = null
-  runOnce = false
-  context: CronContext<C>
-  onComplete?: WithOnComplete<OC> extends true ? CronOnCompleteCallback : undefined
-
-  private _timeout?: NodeJS.Timeout
-  private _callbacks: CronCallback<C, WithOnComplete<OC>>[] = []
-  private _errorHandler?: (error: Error) => void
-
-  constructor(
-    cronTime: CronJobParams<OC, C>['cronTime'],
-    onTick: CronJobParams<OC, C>['onTick'],
-    onComplete?: CronJobParams<OC, C>['onComplete'],
-    start?: CronJobParams<OC, C>['start'],
-    timeZone?: CronJobParams<OC, C>['timeZone'],
-    context?: CronJobParams<OC, C>['context'],
-    runOnInit?: CronJobParams<OC, C>['runOnInit'],
-    utcOffset?: null,
-    unrefTimeout?: CronJobParams<OC, C>['unrefTimeout'],
-    errorHandler?: (error: Error) => void,
-  )
-  constructor(
-    cronTime: CronJobParams<OC, C>['cronTime'],
-    onTick: CronJobParams<OC, C>['onTick'],
-    onComplete?: CronJobParams<OC, C>['onComplete'],
-    start?: CronJobParams<OC, C>['start'],
-    timeZone?: null,
-    context?: CronJobParams<OC, C>['context'],
-    runOnInit?: CronJobParams<OC, C>['runOnInit'],
-    utcOffset?: CronJobParams<OC, C>['utcOffset'],
-    unrefTimeout?: CronJobParams<OC, C>['unrefTimeout'],
-    errorHandler?: (error: Error) => void,
-  )
-  constructor(
-    cronTime: CronJobParams<OC, C>['cronTime'],
-    onTick: CronJobParams<OC, C>['onTick'],
-    onComplete?: CronJobParams<OC, C>['onComplete'],
-    start?: CronJobParams<OC, C>['start'],
-    timeZone?: CronJobParams<OC, C>['timeZone'],
-    context?: CronJobParams<OC, C>['context'],
-    runOnInit?: CronJobParams<OC, C>['runOnInit'],
-    utcOffset?: CronJobParams<OC, C>['utcOffset'],
-    unrefTimeout?: CronJobParams<OC, C>['unrefTimeout'],
-    errorHandler?: (error: Error) => void,
-  ) {
-    this._errorHandler = errorHandler
-    this.context = (context ?? this) as CronContext<C>
-
-    const { timeZone: tz, utcOffset: uo } = getTimeZoneAndOffset(timeZone, utcOffset)
-
-    this.cronTime = new CronTime(cronTime, tz, uo as null | undefined)
-
-    if (unrefTimeout != null) this.unrefTimeout = unrefTimeout
-
-    if (onComplete != null) {
-      // casting to the correct type since we just made sure that WithOnComplete<OC> = true
-      this.onComplete = this._fnWrap(onComplete) as WithOnComplete<OC> extends true ? CronOnCompleteCallback : undefined
-    }
-
-    if (this.cronTime.realDate) this.runOnce = true
-
-    this.addCallback(this._fnWrap(onTick))
-
-    if (runOnInit) {
-      this.lastExecution = new Date()
-      this.fireOnTick()
-    }
-
-    if (start) this.start()
-  }
-
-  static from<OC extends CronOnCompleteCommand | null = null, C = null>(params: CronJobParams<OC, C>) {
-    // runtime check for JS users
-    if (params.timeZone != null && params.utcOffset != null) throw new ExclusiveParametersError('timeZone', 'utcOffset')
-
-    if (params.timeZone != null) {
-      return new CronJob<OC, C>(
-        params.cronTime,
-        params.onTick,
-        params.onComplete,
-        params.start,
-        params.timeZone,
-        params.context,
-        params.runOnInit,
-        params.utcOffset,
-        params.unrefTimeout,
-      )
-    }
-
-    if (params.utcOffset != null) {
-      return new CronJob<OC, C>(
-        params.cronTime,
-        params.onTick,
-        params.onComplete,
-        params.start,
-        null,
-        params.context,
-        params.runOnInit,
-        params.utcOffset,
-        params.unrefTimeout,
-      )
-    }
-
-    return new CronJob<OC, C>(
-      params.cronTime,
-      params.onTick,
-      params.onComplete,
-      params.start,
-      params.timeZone,
-      params.context,
-      params.runOnInit,
-      params.utcOffset,
-      params.unrefTimeout,
-    )
-  }
-
-  private _fnWrap(cmd: CronCommand<C, boolean>): CronCallback<C, boolean> {
-    switch (typeof cmd) {
-      case 'function': {
-        return cmd
-      }
-
-      case 'string': {
-        const [command, ...args] = cmd.split(' ')
-
-        return spawn.bind(undefined, command ?? cmd, args, {}) as () => void
-      }
-
-      case 'object': {
-        return spawn.bind(undefined, cmd.command, cmd.args ?? [], cmd.options ?? {}) as () => void
-      }
-    }
-  }
-
-  addCallback(callback: CronCallback<C, WithOnComplete<OC>>) {
-    if (typeof callback === 'function') this._callbacks.push(callback)
-  }
-
-  setTime(time: CronTime) {
-    if (!(time instanceof CronTime)) throw new CronError('time must be an instance of CronTime.')
-
-    const wasRunning = this.running
-    this.stop()
-
-    this.cronTime = time
-    if (time.realDate) this.runOnce = true
-
-    if (wasRunning) this.start()
-  }
-
-  nextDate() {
-    return this.cronTime.sendAt()
-  }
-
-  fireOnTick() {
-    try {
-      for (const callback of this._callbacks) {
-        void callback.call(
-          this.context,
-          this.onComplete as WithOnComplete<OC> extends true ? CronOnCompleteCallback : never,
-        )
-      }
-    } catch (error) {
-      if (this._errorHandler && error instanceof Error) {
-        this._errorHandler(error)
-      } else {
-        // Handle the case where no error handler is provided or the caught object is not an Error
-        console.error('An error occurred in the cron job callback:', error)
-      }
-    }
-  }
-
-  nextDates(i?: number) {
-    return this.cronTime.sendAt(i ?? 0)
-  }
-
-  start() {
-    if (this.running) return
-
-    const MAXDELAY = 2147483647 // The maximum number of milliseconds setTimeout will wait.
-    let timeout = this.cronTime.getTimeout()
-    let remaining = 0
-    let startTime: number
-
-    const setCronTimeout = (t: number) => {
-      this._timeout = setTimeout(callbackWrapper, t) as NodeJS.Timeout
-      if (this.unrefTimeout && typeof this._timeout.unref === 'function') this._timeout.unref()
-    }
-
-    // The callback wrapper checks if it needs to sleep another period or not
-    // and does the real callback logic when it’s time.
-    const callbackWrapper = () => {
-      const diff = startTime + timeout - Date.now()
-
-      if (diff > 0) {
-        let newTimeout = this.cronTime.getTimeout()
-
-        if (newTimeout > diff) newTimeout = diff
-
-        remaining += newTimeout
-      }
-
-      // If there is sleep time remaining, calculate how long and go to sleep
-      // again. This processing might make us miss the deadline by a few ms
-      // times the number of sleep sessions. Given a MAXDELAY of almost a
-      // month, this should be no issue.
-      if (remaining) {
-        if (remaining > MAXDELAY) {
-          remaining -= MAXDELAY
-          timeout = MAXDELAY
-        } else {
-          timeout = remaining
-          remaining = 0
-        }
-
-        setCronTimeout(timeout)
-      } else {
-        // We have arrived at the correct point in time.
-        this.lastExecution = new Date()
-
-        this.running = false
-
-        // start before calling back so the callbacks have the ability to stop the cron job
-        if (!this.runOnce) this.start()
-
-        this.fireOnTick()
-      }
-    }
-
-    if (timeout >= 0) {
-      this.running = true
-
-      // Don't try to sleep more than MAXDELAY ms at a time.
-
-      if (timeout > MAXDELAY) {
-        remaining = timeout - MAXDELAY
-        timeout = MAXDELAY
-      }
-
-      setCronTimeout(timeout)
-    } else {
-      this.stop()
-    }
-  }
-
-  lastDate() {
-    return this.lastExecution
-  }
-
-  /**
-   * Stop the cronjob.
-   */
-  stop() {
-    if (this._timeout) clearTimeout(this._timeout)
-    this.running = false
-    if (typeof this.onComplete === 'function') void this.onComplete.call(this.context)
-  }
-}