Walidator wyrażeń Cron

import { parseExpression } from 'cron-parser';

// Validate a cron expression by attempting to parse it
function validateCron(expr) {
  try {
    parseExpression(expr);
    return { valid: true, error: null };
  } catch (err) {
    return { valid: false, error: err.message };
  }
}

console.log(validateCron('0 9 * * 1-5'));
// → { valid: true, error: null }

console.log(validateCron('0 25 * * *'));
// → { valid: false, error: "Constraint error, got value 25 expected range 0-23" }

// Validate with field-level detail using cron-validator
import { isValidCron } from 'cron-validator';

isValidCron('*/15 * * * *');           // → true
isValidCron('*/15 * * * *', { seconds: true }); // → false (expects 6 fields)
isValidCron('0 0 31 2 *');             // → true (syntactically valid, Feb 31 never fires)

from croniter import croniter

# Validate by checking if croniter can parse the expression
def validate_cron(expr: str) -> dict:
    if croniter.is_valid(expr):
        return {"valid": True, "error": None}
    # Get a more specific error message
    try:
        croniter(expr)
    except (ValueError, KeyError) as e:
        return {"valid": False, "error": str(e)}
    return {"valid": False, "error": "Unknown error"}

print(validate_cron("0 9 * * 1-5"))
# → {'valid': True, 'error': None}

print(validate_cron("0 25 * * *"))
# → {'valid': False, 'error': '...out of range...'}

print(validate_cron("* * *"))
# → {'valid': False, 'error': 'Exactly 5 or 6 columns...'}

# Field-level validation
from crontab import CronTab

cron = CronTab(tab="")
job = cron.new(command="/bin/true")
try:
    job.setall("0 9 * * 1-5")
    print(job.is_valid())  # → True
except Exception as e:
    print(f"Invalid: {e}")

package main

import (
    "fmt"
    "github.com/robfig/cron/v3"
)

// ValidateCron checks whether a 5-field cron expression is syntactically correct
func ValidateCron(expr string) (bool, error) {
    parser := cron.NewParser(
        cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow,
    )
    _, err := parser.Parse(expr)
    if err != nil {
        return false, err
    }
    return true, nil
}

func main() {
    exprs := []string{
        "0 9 * * 1-5",   // valid
        "0 25 * * *",    // invalid: hour 25
        "*/15 * * * *",  // valid
        "0 0 32 * *",    // invalid: day 32
    }

    for _, e := range exprs {
        ok, err := ValidateCron(e)
        if ok {
            fmt.Printf("%-20s  VALID
", e)
        } else {
            fmt.Printf("%-20s  INVALID: %v
", e, err)
        }
    }
}

#!/bin/bash

# Validate cron syntax using Python one-liner
validate_cron() {
  python3 -c "
from croniter import croniter
import sys
expr = sys.argv[1]
if croniter.is_valid(expr):
    print(f'VALID: {expr}')
    sys.exit(0)
else:
    print(f'INVALID: {expr}')
    sys.exit(1)
" "$1"
}

validate_cron "0 9 * * 1-5"     # → VALID: 0 9 * * 1-5
validate_cron "0 25 * * *"      # → INVALID: 0 25 * * *

# Quick regex pre-check (catches field count and obvious issues)
cron_regex='^([0-9*/,-]+\s+){4}[0-9*/,-]+$'
echo "*/5 * * * *" | grep -Eq "$cron_regex" && echo "passes basic check"
echo "* * *" | grep -Eq "$cron_regex" || echo "fails basic check"