stacks 0.58.50 → 0.58.52

package/core/scheduler/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/scheduler",
   "type": "module",
-  "version": "0.58.50",
+  "version": "0.58.52",
   "description": "The Stacks scheduler.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -17,6 +17,9 @@
   },
   "keywords": [
     "scheduler",
+    "node-cron",
+    "jobs",
+    "bun",
     "stacks"
   ],
   "exports": {
@@ -45,13 +48,13 @@
     "prepublishOnly": "bun --bun run build"
   },
   "peerDependencies": {
-    "node-cron": "3.0.3"
+    "luxon": "^3.4.4"
   },
   "dependencies": {
-    "node-cron": "3.0.3"
+    "luxon": "^3.4.4"
   },
   "devDependencies": {
     "@stacksjs/development": "workspace:*",
-    "@types/node-cron": "^3.0.11"
+    "sinon": "^17.0.1"
   }
 }

package/core/scheduler/src/constants.ts

@@ -0,0 +1,81 @@
+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/core/scheduler/src/errors.ts

@@ -0,0 +1,7 @@
+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/core/scheduler/src/index.ts

@@ -1,321 +1,19 @@
-import cron from 'node-cron'
+import { Schedule } from './schedule'
 
-// export interface Scheduler {
-//   schedule(schedule: Schedule): void
-// }
+export { CronJob } from './job'
+export { CronTime } from './time'
 
-export interface Schedule {
-  action(action: string): this
-  command(cmd: string): this
-  job(job: string): this
-  exec(cmd: string): this
-  call(callback: () => void): this
-  everyMinute(): this
-  everySecond(): this
-  everyFiveMinutes(): this
-  everyTenMinutes(): this
-  everyThirtyMinutes(): this
-  hourly(): this
-  daily(): this
-  twiceDaily(hour1: number, hour2: number): this
-  weekly(): this
-  monthly(): this
-  quarterly(): this
-  yearly(): this
-  weekdays(): this
-  weekends(): this
-  mondays(): this
-  tuesdays(): this
-  wednesdays(): this
-  thursdays(): this
-  fridays(): this
-  saturdays(): this
-  sundays(): this
-  between(startTime: string, endTime: string): this
-  timezone(timezone: string): this
-  when(callback: () => boolean): this
-  at(time: string): this
-}
+export type {
+  CronCallback,
+  CronCommand,
+  CronContext,
+  CronJobParams,
+  CronOnCompleteCallback,
+  CronOnCompleteCommand,
+  Ranges,
+  TimeUnit,
+} from './types/cron'
 
-export class ScheduleImpl implements Schedule {
-  private actionName: string = ''
-  private commandName: string = ''
-  private jobName: string = ''
-  private execName: string = ''
-  private callback: () => void = () => {}
-  private whenCallback: () => boolean = () => true
-  private startTime: string = ''
-  private endTime: string = ''
-  private timezoneName: string = ''
-  private time: string = ''
+export * from './schedule'
 
-  action(action: string): this {
-    this.actionName = action
-    return this
-  }
-
-  command(cmd: string): this {
-    this.commandName = cmd
-    return this
-  }
-
-  job(job: string): this {
-    this.jobName = job
-    return this
-  }
-
-  exec(cmd: string): this {
-    this.execName = cmd
-    return this
-  }
-
-  call(callback: () => void): this {
-    this.callback = callback
-    return this
-  }
-
-  everyMinute(): this {
-    // implementation here
-    return this
-  }
-
-  everySecond(): this {
-    // implementation here
-    return this
-  }
-
-  everyFiveMinutes(): this {
-    // implementation here
-    return this
-  }
-
-  everyTenMinutes(): this {
-    // implementation here
-    return this
-  }
-
-  everyThirtyMinutes(): this {
-    // implementation here
-    return this
-  }
-
-  hourly(): this {
-    // implementation here
-    return this
-  }
-
-  daily(): this {
-    // implementation here
-    return this
-  }
-
-  twiceDaily(_hour1: number, _hour2: number): this {
-    // implementation here
-    return this
-  }
-
-  weekly(): this {
-    // implementation here
-    return this
-  }
-
-  monthly(): this {
-    // implementation here
-    return this
-  }
-
-  quarterly(): this {
-    // implementation here
-    return this
-  }
-
-  yearly(): this {
-    // implementation here
-    return this
-  }
-
-  weekdays(): this {
-    // implementation here
-    return this
-  }
-
-  weekends(): this {
-    // implementation here
-    return this
-  }
-
-  mondays(): this {
-    // implementation here
-    return this
-  }
-
-  tuesdays(): this {
-    // implementation here
-    return this
-  }
-
-  wednesdays(): this {
-    // implementation here
-    return this
-  }
-
-  thursdays(): this {
-    // implementation here
-    return this
-  }
-
-  fridays(): this {
-    // implementation here
-    return this
-  }
-
-  saturdays(): this {
-    // implementation here
-    return this
-  }
-
-  sundays(): this {
-    // implementation here
-    return this
-  }
-
-  between(startTime: string, endTime: string): this {
-    this.startTime = startTime
-    this.endTime = endTime
-    return this
-  }
-
-  timezone(timezone: string): this {
-    this.timezoneName = timezone
-    return this
-  }
-
-  when(callback: () => boolean): this {
-    this.whenCallback = callback
-    return this
-  }
-
-  at(time: string): this {
-    this.time = time
-    return this
-  }
-}
-
-export interface Scheduler {
-  everySecond: () => void
-  everySeconds: (seconds: number) => void
-  everyMinute: () => void
-  everyMinutes: (minutes: number) => void
-  everyTwoMinutes: () => void
-  everyThreeMinutes: () => void
-  everyFourMinutes: () => void
-  everyFiveMinutes: () => void
-  everyTenMinutes: () => void
-  everyFifteenMinutes: () => void
-  everyThirtyMinutes: () => void
-  hourly: () => void
-  hourlyAt: (minute: number) => void
-  everyOddHour: () => void
-  everyHours: (hours: number) => void
-  everyTwoHours: () => void
-  everyThreeHours: () => void
-  everyFourHours: () => void
-  everySixHours: () => void
-  daily: () => void
-  dailyAt: (hour: number, minute: number) => void
-  everyDays: (days: number) => void
-  weekly: () => void
-  quarterly: () => void
-  yearly: () => void
-  cron: (interval: string, timezone?: string) => void
-}
-
-// function run(callback: Function): Scheduler {
-export function run(callback: ((now: Date | 'manual' | 'init') => void) | string): Scheduler {
-  return {
-    everySecond: () => {
-      cron.schedule('* * * * * *', callback)
-    },
-    everySeconds: (seconds = 1) => {
-      cron.schedule(`*/${seconds} * * * * *`, callback)
-    },
-    everyMinute: () => {
-      cron.schedule('* * * * *', callback)
-    },
-    everyTwoMinutes: () => {
-      cron.schedule('*/2 * * * *', callback)
-    },
-    everyThreeMinutes: () => {
-      cron.schedule('*/3 * * * *', callback)
-    },
-    everyFourMinutes: () => {
-      cron.schedule('*/4 * * * *', callback)
-    },
-    everyFiveMinutes: () => {
-      cron.schedule('*/5 * * * *', callback)
-    },
-    everyTenMinutes: () => {
-      cron.schedule('*/10 * * * *', callback)
-    },
-    everyFifteenMinutes: () => {
-      cron.schedule('*/15 * * * *', callback)
-    },
-    everyThirtyMinutes: () => {
-      cron.schedule('*/30 * * * *', callback)
-    },
-    everyMinutes: (minutes: number) => {
-      cron.schedule(`*/${minutes} * * * *`, callback)
-    },
-    hourly: () => {
-      cron.schedule('0 * * * *', callback)
-    },
-    everyHours: (hours: number) => {
-      cron.schedule(`0 */${hours} * * *`, callback)
-    },
-    hourlyAt: (minute: number) => {
-      cron.schedule(`${minute} * * * *`, callback)
-    },
-    everyOddHour: () => {
-      cron.schedule('0 */2 * * *', callback)
-    },
-    everyTwoHours: () => {
-      cron.schedule('0 */2 * * *', callback)
-    },
-    everyThreeHours: () => {
-      cron.schedule('0 */3 * * *', callback)
-    },
-    everyFourHours: () => {
-      cron.schedule('0 */4 * * *', callback)
-    },
-    everySixHours: () => {
-      cron.schedule('0 */6 * * *', callback)
-    },
-    dailyAt: (hour: number, minute: number) => {
-      cron.schedule(`${minute} ${hour} * * *`, callback)
-    },
-    daily: () => {
-      cron.schedule('0 0 * * *', callback)
-    },
-    everyDays: (days: number) => {
-      cron.schedule(`0 0 */${days} * *`, callback)
-    },
-    weekly: () => {
-      cron.schedule('0 0 * * 0', callback)
-    },
-    quarterly: () => {
-      cron.schedule('0 0 1 */3 *', callback)
-    },
-    yearly: () => {
-      cron.schedule('0 0 1 1 *', callback)
-    },
-    cron: (interval: string, timezone?: string) => {
-      timezone ? cron.schedule(interval, callback, { scheduled: true, timezone }) : cron.schedule(interval, callback)
-    },
-  }
-}
-
-export function useScheduler() {
-  return {
-    run,
-  }
-}
+export default Schedule