semola 0.5.3 → 0.6.0

package/dist/lib/cron/index.mjs

@@ -1,4 +1,726 @@
-import { any, cronJobBuilder, list, number, range, step } from "../../cron/builder/index.mjs";
-import { Month, WeekDay } from "../../cron/builder/types.mjs";
-import { Cron } from "../../cron/core/index.mjs";
+import { mightThrow } from "../errors/index.mjs";
+//#region src/lib/cron/builder/index.ts
+const CRON_FIELD_ORDER = [
+	"second",
+	"minute",
+	"hour",
+	"day",
+	"month",
+	"weekday"
+];
+var FieldWrapper = class {
+	fields = [];
+	add(expr) {
+		this.fields.push(expr);
+	}
+	read() {
+		return this.fields;
+	}
+};
+var CronListBuilder = class {
+	wrapper;
+	constructor(wrapper) {
+		this.wrapper = wrapper;
+	}
+	any() {
+		this.wrapper.add({ type: "any" });
+		return this;
+	}
+	range(options) {
+		this.wrapper.add({
+			type: "range",
+			...options
+		});
+		return this;
+	}
+	step(options) {
+		this.wrapper.add({
+			type: "step",
+			...options
+		});
+		return this;
+	}
+	number(value) {
+		this.wrapper.add({
+			type: "value",
+			value
+		});
+		return this;
+	}
+};
+function range(options) {
+	return {
+		type: "range",
+		...options
+	};
+}
+function any() {
+	return { type: "any" };
+}
+function step(options) {
+	return {
+		type: "step",
+		...options
+	};
+}
+function list(builderFn) {
+	const wrapper = new FieldWrapper();
+	builderFn(new CronListBuilder(wrapper));
+	return {
+		type: "list",
+		values: wrapper.read()
+	};
+}
+function number(value) {
+	return {
+		type: "value",
+		value
+	};
+}
+function cronJobBuilder(buildFn) {
+	const fields = {
+		second: void 0,
+		minute: void 0,
+		hour: void 0,
+		day: void 0,
+		month: void 0,
+		weekday: void 0
+	};
+	const obj = {
+		second(expr) {
+			fields.second = checkExpr(expr);
+			return obj;
+		},
+		minute(expr) {
+			fields.minute = checkExpr(expr);
+			return obj;
+		},
+		hour(expr) {
+			fields.hour = checkExpr(expr);
+			return obj;
+		},
+		day(expr) {
+			fields.day = checkExpr(expr);
+			return obj;
+		},
+		month(expr) {
+			fields.month = checkExpr(expr);
+			return obj;
+		},
+		weekday(expr) {
+			fields.weekday = checkExpr(expr);
+			return obj;
+		}
+	};
+	buildFn(obj);
+	return generate(fields);
+}
+function checkExpr(expr) {
+	if (expr.type === "list") {
+		const { values } = expr;
+		if (values.length === 0) throw new Error("EmptyListError: List expression cannot be empty");
+		return values.map((e) => handleSimpleExpression(e)).join(",");
+	}
+	return handleSimpleExpression(expr);
+}
+function handleSimpleExpression(expr) {
+	switch (expr.type) {
+		case "any": return "*";
+		case "value": return `${expr.value}`;
+		case "range": {
+			const { min, max } = expr;
+			if (min > max) throw new Error(`OutOfBoundError: Expected ${min} <= ${max}`);
+			return `${min}-${max}`;
+		}
+		case "step": {
+			const { step, range } = expr;
+			if (step === 0) throw new Error(`OutOfBoundError: Expected step value greater than zero`);
+			if (!range) return `*/${step}`;
+			const { min, max } = range;
+			if (max === 0) {
+				if (min > max) throw new Error(`OutOfBoundError: Expected max value greater than zero`);
+				return `${min}-${max}/${step}`;
+			}
+			if (!max) return `${min}/${step}`;
+			if (min > max) throw new Error(`OutOfBoundError: Expected ${min} <= ${max}`);
+			return `${min}-${max}/${step}`;
+		}
+		default: return "*";
+	}
+}
+function generate(fields) {
+	const parts = [];
+	for (let index = 0; index < CRON_FIELD_ORDER.length; index++) {
+		const key = CRON_FIELD_ORDER[index];
+		if (!key) return "";
+		if (key === "second" && !fields[key]) continue;
+		parts.push(fields[key] ?? "*");
+	}
+	return parts.join(" ");
+}
+//#endregion
+//#region src/lib/cron/builder/types.ts
+const WeekDay = {
+	sun: 0,
+	mon: 1,
+	tue: 2,
+	wed: 3,
+	thu: 4,
+	fri: 5,
+	sat: 6
+};
+const Month = {
+	jan: 1,
+	feb: 2,
+	mar: 3,
+	apr: 4,
+	may: 5,
+	jun: 6,
+	jul: 7,
+	aug: 8,
+	sep: 9,
+	oct: 10,
+	nov: 11,
+	dec: 12
+};
+//#endregion
+//#region src/lib/cron/errors.ts
+var InvalidValueError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidValueError";
+	}
+};
+var OutOfBoundError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OutOfBoundError";
+	}
+};
+var CronExpressionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CronExpressionError";
+	}
+};
+var EmptyCronExpressionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "EmptyCronExpressionError";
+	}
+};
+var CronLengthError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CronLengthError";
+	}
+};
+//#endregion
+//#region src/lib/cron/core/scanner.ts
+const FieldAmount = {
+	min: 5,
+	max: 6
+};
+var Token = class {
+	type;
+	component;
+	value;
+	field;
+	constructor(component, type, value, field) {
+		this.component = component;
+		this.type = type;
+		this.value = value;
+		this.field = field;
+	}
+	getComponent() {
+		return this.component;
+	}
+	getTokenType() {
+		return this.type;
+	}
+	getTokenValue() {
+		return this.value;
+	}
+	getField() {
+		return this.field;
+	}
+	toString() {
+		return `Token{${`component="${this.component}", type=${this.type}`}, ${`field="${this.field}", value=${this.value}`}}`;
+	}
+	equals(other) {
+		if (!other) return false;
+		const isComponentEqual = this.component === other.getComponent();
+		const isTokenTypeEqual = this.type === other.getTokenType();
+		const isTokenValueEqual = this.value === other.getTokenValue();
+		const isFieldEqual = this.field === other.getField();
+		return isComponentEqual && isTokenTypeEqual && isTokenValueEqual && isFieldEqual;
+	}
+};
+var Scanner = class {
+	expression;
+	current;
+	start;
+	tokens;
+	constructor(expression) {
+		this.expression = expression;
+		this.current = 0;
+		this.start = 0;
+		this.tokens = [];
+	}
+	scan() {
+		if (this.expression.length === 0) throw new EmptyCronExpressionError("Cron expression have zero length");
+		const fields = this.expression.trim().split(/\s+/);
+		const hasMinLen = fields.length === FieldAmount.min;
+		const hasMaxLen = fields.length === FieldAmount.max;
+		if (!hasMinLen && !hasMaxLen) throw new CronLengthError(`Invalid number of fields for '${this.expression}'. Expected 5 or 6 fields but got ${fields.length} field(s)`);
+		const components = this.createComponent(fields);
+		for (let idx = 0; idx < components.length; idx++) {
+			const component = components[idx];
+			if (!component) throw new CronExpressionError(`Invalid cron expression: ${this.expression}`);
+			this.current = 0;
+			this.start = 0;
+			this.scanComponent(component);
+		}
+		return this.tokens;
+	}
+	scanComponent(component) {
+		const { field, content } = component;
+		while (this.current < content.length) {
+			let currentCh = this.advance(content);
+			switch (currentCh) {
+				case "*": {
+					const ch = this.peek(content);
+					if (this.match(content, "/")) this.handleStep(component);
+					else if (!ch || ch === ",") this.addToken("*", "any", "*", field);
+					else throw new CronExpressionError(`Invalid any expression '${content}' for field '${field}'`);
+					break;
+				}
+				case "-":
+					currentCh = this.advance(content);
+					if (this.isDigit(currentCh)) this.handleRangeWithStep(component);
+					else throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
+					break;
+				case ",": {
+					if (this.current === 1 && this.start === 0) throw new CronExpressionError(`Invalid list expression '${content}' for field '${field}'`);
+					const next = this.peek(content);
+					if (!next || next === ",") throw new CronExpressionError(`Invalid list expression '${content}' for field '${field}'`);
+					break;
+				}
+				default:
+					if (this.isDigit(currentCh)) this.handleNumber(component);
+					else throw new CronExpressionError(`Invalid cron expression '${this.expression}' in field '${field}'`);
+					break;
+			}
+			this.start = this.current;
+		}
+		return true;
+	}
+	addToken(component, type, value, field) {
+		const token = new Token(component, type, value, field);
+		this.tokens.push(token);
+	}
+	advance(content) {
+		const currentCh = content.charAt(this.current);
+		this.current += 1;
+		return currentCh;
+	}
+	match(content, expected) {
+		if (this.current >= content.length) return false;
+		if (content.charAt(this.current) !== expected) return false;
+		this.current += 1;
+		return true;
+	}
+	peek(content) {
+		if (this.current >= content.length) return void 0;
+		return content.charAt(this.current);
+	}
+	handleStep(component) {
+		const { field, content } = component;
+		let ch = this.peek(content);
+		const slashIdx = this.current - 1;
+		while (ch && this.isDigit(ch)) {
+			this.advance(content);
+			ch = this.peek(content);
+		}
+		if (ch && ch !== ",") throw new CronExpressionError(`Invalid step expression '${content}' for field '${field}'`);
+		const tokenContent = content.substring(this.start, this.current);
+		const value = content.slice(slashIdx + 1, this.current);
+		if (value.length === 0) throw new CronExpressionError(`Invalid step expression '${content}' for field '${field}'`);
+		this.addToken(tokenContent, "step", Number(value), field);
+		return true;
+	}
+	handleRangeWithStep(component) {
+		const { field, content } = component;
+		let ch = this.peek(content);
+		while (ch && this.isDigit(ch)) {
+			this.advance(content);
+			ch = this.peek(content);
+		}
+		if (!ch) throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
+		if (this.match(content, "/")) {
+			this.handleStep(component);
+			return true;
+		}
+		throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
+	}
+	handleNumber(component) {
+		const { field, content } = component;
+		let ch = this.peek(content);
+		this.start = this.current - 1;
+		while (ch && this.isDigit(ch)) {
+			this.advance(content);
+			ch = this.peek(content);
+		}
+		if (!ch) {
+			const item = content.substring(this.start);
+			this.addToken(item, "number", Number(item), field);
+			return true;
+		}
+		if (this.match(content, "-")) {
+			this.handleRange(component);
+			return true;
+		}
+		if (this.match(content, "/")) {
+			this.handleStep(component);
+			return true;
+		}
+		if (!this.isDigit(ch) && ch !== ",") throw new CronExpressionError(`Invalid number '${content}' for field '${field}'`);
+		const item = content.substring(this.start, this.current);
+		this.addToken(item, "number", Number(item), field);
+		return true;
+	}
+	handleRange(component) {
+		const { field, content } = component;
+		let ch = this.peek(content);
+		if (!ch) throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
+		while (ch && this.isDigit(ch)) {
+			this.advance(content);
+			ch = this.peek(content);
+		}
+		if (!ch) {
+			const tokenContent = content.substring(this.start);
+			this.addToken(tokenContent, "range", tokenContent, field);
+			return true;
+		}
+		if (this.match(content, "/")) {
+			this.handleStep(component);
+			return true;
+		}
+		if (ch && ch !== ",") throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
+		const tokenContent = content.substring(this.start, this.current);
+		this.addToken(tokenContent, "range", tokenContent, field);
+		return true;
+	}
+	isDigit(ch) {
+		return ch >= "0" && ch <= "9";
+	}
+	createComponent(fields) {
+		const fieldNames = [
+			"second",
+			"minute",
+			"hour",
+			"day",
+			"month",
+			"weekday"
+		];
+		const components = [];
+		let offset = 1;
+		if (fields.length === FieldAmount.max) offset = 0;
+		for (let idx = 0; idx < fields.length; idx++) {
+			const fieldName = fieldNames[idx + offset];
+			const content = fields[idx];
+			if (!fieldName || !content) break;
+			components.push({
+				content,
+				field: fieldName
+			});
+		}
+		return components;
+	}
+};
+//#endregion
+//#region src/lib/cron/core/index.ts
+const RETRY_DELAY_MS = 3600 * 1e3;
+const MAX_YEARS = 4;
+const ALIASES = {
+	"@yearly": "0 0 1 1 *",
+	"@monthly": "0 0 1 * *",
+	"@weekly": "0 0 * * 0",
+	"@daily": "0 0 * * *",
+	"@hourly": "0 * * * *",
+	"@minutely": "* * * * *"
+};
+const CronSecondRange = {
+	min: 0,
+	max: 59
+};
+const CronMinuteRange = {
+	min: 0,
+	max: 59
+};
+const CronHourRange = {
+	min: 0,
+	max: 23
+};
+const CronDayRange = {
+	min: 1,
+	max: 31
+};
+const CronMonthRange = {
+	min: 1,
+	max: 12
+};
+const CronDayOfWeekRange = {
+	min: 0,
+	max: 6
+};
+var Cron = class {
+	options;
+	status = "idle";
+	timeoutId = null;
+	second = Array(CronSecondRange.max + 1).fill(0);
+	minute = Array(CronMinuteRange.max + 1).fill(0);
+	hour = Array(CronHourRange.max + 1).fill(0);
+	day = Array(CronDayRange.max + 1).fill(0);
+	month = Array(CronMonthRange.max + 1).fill(0);
+	dayOfWeek = Array(CronDayOfWeekRange.max + 1).fill(0);
+	hasSeconds;
+	_dayWildcard = false;
+	_dowWildcard = false;
+	fillRange(values, min, max) {
+		for (let i = min; i <= max; i++) values[i] = 1;
+	}
+	handleStep(part, values, min, max) {
+		const [rangePart, stepStr] = part.split("/");
+		if (!rangePart) throw new InvalidValueError(`'${rangePart}' is empty`);
+		if (!stepStr) throw new InvalidValueError(`'${stepStr}' is empty`);
+		const step = Number(stepStr);
+		if (!Number.isInteger(step)) throw new InvalidValueError(`'${step}' is not a valid number`);
+		if (step <= 0) throw new OutOfBoundError(`Expected ${step} > 0`);
+		if (rangePart === "*") {
+			for (let i = min; i <= max; i += step) values[i] = 1;
+			return;
+		}
+		if (rangePart.includes("-")) {
+			this.handleStepRange(rangePart, step, values, min, max);
+			return;
+		}
+		this.handleStepSingle(rangePart, step, values, min, max);
+	}
+	handleStepRange(range, step, values, min, max) {
+		const [startStr, endStr] = range.split("-");
+		if (!endStr) throw new InvalidValueError(`'${endStr}' is empty`);
+		let start = min;
+		if (startStr && startStr.length > 0) start = Number(startStr);
+		const end = Number(endStr);
+		if (!Number.isInteger(start)) throw new InvalidValueError(`'${start}' is not a valid number`);
+		if (!Number.isInteger(end)) throw new InvalidValueError(`'${end}' is not a valid number`);
+		if (start < min) throw new OutOfBoundError(`Expected ${start} >= ${min}`);
+		if (end > max) throw new OutOfBoundError(`Expected ${end} <= ${max}`);
+		if (start > end) throw new OutOfBoundError(`Expected ${start} <= ${end}`);
+		for (let i = start; i <= end; i += step) values[i] = 1;
+	}
+	handleStepSingle(value, step, values, min, max) {
+		const start = Number(value);
+		if (!Number.isInteger(start)) throw new InvalidValueError(`'${start}' is not a valid number`);
+		if (start < min) throw new OutOfBoundError(`Expected ${start} >= ${min}`);
+		if (start > max) throw new OutOfBoundError(`Expected ${start} <= ${max}`);
+		for (let i = start; i <= max; i += step) values[i] = 1;
+	}
+	handleRange(part, values, min, max) {
+		const [startStr, endStr] = part.split("-");
+		if (!startStr) throw new InvalidValueError(`'${startStr}' is empty`);
+		if (!endStr) throw new InvalidValueError(`'${endStr}' is empty`);
+		const start = Number(startStr);
+		const end = Number(endStr);
+		if (!Number.isInteger(start)) throw new InvalidValueError(`'${start}' is not a valid number`);
+		if (!Number.isInteger(end)) throw new InvalidValueError(`'${end}' is not a valid number`);
+		if (start < min) throw new OutOfBoundError(`Expected ${start} >= ${min}`);
+		if (end > max) throw new OutOfBoundError(`Expected ${end} <= ${max}`);
+		if (start > end) throw new OutOfBoundError(`Expected ${start} <= ${end}`);
+		for (let i = start; i <= end; i++) values[i] = 1;
+	}
+	handleNumber(value, values, min, max) {
+		const n = Number(value);
+		if (!Number.isInteger(n)) throw new InvalidValueError(`'${value}' is not a valid number`);
+		if (n < min) throw new OutOfBoundError(`Expected ${n} >= ${min}`);
+		if (n > max) throw new OutOfBoundError(`Expected ${n} <= ${max}`);
+		values[n] = 1;
+	}
+	constructor(options) {
+		this.options = options;
+		const expr = this.resolveAlias(options.schedule);
+		const tokens = new Scanner(expr).scan();
+		this.hasSeconds = expr.trim().split(/\s+/).length === FieldAmount.max;
+		this.parse(tokens);
+	}
+	resolveAlias(schedule) {
+		return ALIASES[schedule] || schedule;
+	}
+	parse(tokens) {
+		for (let i = 0; i < tokens.length; i++) {
+			const token = tokens[i];
+			if (!token) throw new InvalidValueError("Undefined token");
+			const tokenType = token.getTokenType();
+			switch (token.getField()) {
+				case "second":
+					this.handleField(token, this.second, CronSecondRange.min, CronSecondRange.max);
+					break;
+				case "minute":
+					this.handleField(token, this.minute, CronMinuteRange.min, CronMinuteRange.max);
+					break;
+				case "hour":
+					this.handleField(token, this.hour, CronHourRange.min, CronHourRange.max);
+					break;
+				case "day":
+					if (tokenType === "any") this._dayWildcard = true;
+					this.handleField(token, this.day, CronDayRange.min, CronDayRange.max);
+					break;
+				case "month":
+					this.handleField(token, this.month, CronMonthRange.min, CronMonthRange.max);
+					break;
+				case "weekday":
+					if (tokenType === "any") this._dowWildcard = true;
+					this.handleField(token, this.dayOfWeek, CronDayOfWeekRange.min, CronDayOfWeekRange.max);
+					break;
+				default: throw new InvalidValueError(`Invalid field '${token.getField()}'`);
+			}
+		}
+	}
+	handleField(token, field, min, max) {
+		switch (token.getTokenType()) {
+			case "any":
+				this.fillRange(field, min, max);
+				break;
+			case "number":
+				this.handleNumber(token.getComponent(), field, min, max);
+				break;
+			case "range": {
+				const component = token.getComponent();
+				this.handleRange(component, field, min, max);
+				break;
+			}
+			case "step": {
+				const component = token.getComponent();
+				this.handleStep(component, field, min, max);
+				break;
+			}
+			default: throw new InvalidValueError(`Invalid token type '${token.getTokenType()}'`);
+		}
+	}
+	matches(date) {
+		const s = date.getSeconds();
+		const m = date.getMinutes();
+		const h = date.getHours();
+		const d = date.getDate();
+		const mon = date.getMonth();
+		const dow = date.getDay();
+		const isSecondMatch = this.hasSeconds ? this.second[s] === 1 : true;
+		const isMinuteMatch = this.minute[m] === 1;
+		const isHourMatch = this.hour[h] === 1;
+		const isMonthMatch = this.month[mon + 1] === 1;
+		let isDayOrDowMatch;
+		if (!this._dayWildcard && !this._dowWildcard) isDayOrDowMatch = this.day[d] === 1 || this.dayOfWeek[dow] === 1;
+		else isDayOrDowMatch = this.day[d] === 1 && this.dayOfWeek[dow] === 1;
+		return isSecondMatch && isMinuteMatch && isHourMatch && isDayOrDowMatch && isMonthMatch;
+	}
+	getNextRun() {
+		const date = /* @__PURE__ */ new Date();
+		if (this.hasSeconds) {
+			date.setMilliseconds(0);
+			date.setSeconds(date.getSeconds() + 1);
+		} else {
+			date.setSeconds(0, 0);
+			date.setMinutes(date.getMinutes() + 1);
+		}
+		const deadline = new Date(date);
+		deadline.setFullYear(deadline.getFullYear() + MAX_YEARS);
+		while (date < deadline) {
+			const s = date.getSeconds();
+			const m = date.getMinutes();
+			const h = date.getHours();
+			const d = date.getDate();
+			const mon = date.getMonth();
+			const dow = date.getDay();
+			if (this.month[mon + 1] === 0) {
+				date.setDate(1);
+				date.setMonth(mon + 1);
+				date.setHours(0, 0, 0, 0);
+				continue;
+			}
+			let isDayOrDowMatch;
+			if (!this._dayWildcard && !this._dowWildcard) isDayOrDowMatch = this.day[d] === 0 && this.dayOfWeek[dow] === 0;
+			else isDayOrDowMatch = this.day[d] === 0 || this.dayOfWeek[dow] === 0;
+			if (isDayOrDowMatch) {
+				date.setDate(d + 1);
+				date.setHours(0, 0, 0, 0);
+				continue;
+			}
+			if (this.hour[h] === 0) {
+				date.setHours(h + 1);
+				date.setMinutes(0, 0, 0);
+				continue;
+			}
+			if (this.minute[m] === 0) {
+				date.setMinutes(m + 1);
+				date.setSeconds(0, 0);
+				continue;
+			}
+			if (this.hasSeconds && this.second[s] === 0) {
+				date.setSeconds(s + 1);
+				date.setMilliseconds(0);
+				continue;
+			}
+			return new Date(date);
+		}
+		return null;
+	}
+	start() {
+		if (this.status !== "idle") return;
+		this.status = "running";
+		this.next();
+	}
+	stop() {
+		this.status = "idle";
+		if (this.timeoutId) {
+			clearTimeout(this.timeoutId);
+			this.timeoutId = null;
+		}
+	}
+	pause() {
+		if (this.status !== "running") return;
+		this.status = "paused";
+		if (this.timeoutId) {
+			clearTimeout(this.timeoutId);
+			this.timeoutId = null;
+		}
+	}
+	resume() {
+		if (this.status !== "paused") return;
+		this.status = "running";
+		this.next();
+	}
+	getStatus() {
+		return this.status;
+	}
+	next() {
+		if (this.status !== "running") return;
+		const nextRun = this.getNextRun();
+		if (!nextRun) {
+			this.timeoutId = setTimeout(() => this.next(), RETRY_DELAY_MS);
+			return;
+		}
+		const delay = nextRun.getTime() - Date.now();
+		this.timeoutId = setTimeout(() => {
+			this.run();
+		}, Math.max(0, delay));
+	}
+	async run() {
+		if (this.status !== "running") return;
+		const handlerResult = this.options.handler();
+		await mightThrow(Promise.resolve(handlerResult));
+		if (this.status === "running") this.next();
+	}
+};
+//#endregion
 export { Cron, Month, WeekDay, any, cronJobBuilder, list, number, range, step };