semola 0.5.4 → 0.6.0

package/dist/lib/cron/index.mjs

@@ -1,4 +1,4 @@
-import { err, mightThrow, ok } from "../errors/index.mjs";
+import { mightThrow } from "../errors/index.mjs";
 //#region src/lib/cron/builder/index.ts
 const CRON_FIELD_ORDER = [
 	"second",
@@ -184,6 +184,38 @@ const Month = {
 	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,
@@ -236,21 +268,20 @@ var Scanner = class {
 		this.tokens = [];
 	}
 	scan() {
-		if (this.expression.length === 0) return err("EmptyCronExpressionError", "Cron expression have zero length");
+		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) return err("CronLengthError", `Invalid number of fields for '${this.expression}'. Expected 5 or 6 fields but got ${fields.length} field(s)`);
+		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) return err("CronExpressionError", `Invalid cron expression: ${this.expression}`);
+			if (!component) throw new CronExpressionError(`Invalid cron expression: ${this.expression}`);
 			this.current = 0;
 			this.start = 0;
-			const [error, _] = this.scanComponent(component);
-			if (error) return err(error.type, error.message);
+			this.scanComponent(component);
 		}
-		return ok(this.tokens);
+		return this.tokens;
 	}
 	scanComponent(component) {
 		const { field, content } = component;
@@ -259,36 +290,30 @@ var Scanner = class {
 			switch (currentCh) {
 				case "*": {
 					const ch = this.peek(content);
-					if (this.match(content, "/")) {
-						const [error, _] = this.handleStep(component);
-						if (error) return err(error.type, error.message);
-					} else if (!ch || ch === ",") this.addToken("*", "any", "*", field);
-					else return err("CronExpressionError", `Invalid any expression '${content}' for field '${field}'`);
+					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)) {
-						const [error, _] = this.handleRangeWithStep(component);
-						if (error) return err(error.type, error.message);
-					} else return err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+					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) return err("CronExpressionError", `Invalid list expression '${content}' for field '${field}'`);
+					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 === ",") return err("CronExpressionError", `Invalid list expression '${content}' for field '${field}'`);
+					if (!next || next === ",") throw new CronExpressionError(`Invalid list expression '${content}' for field '${field}'`);
 					break;
 				}
 				default:
-					if (this.isDigit(currentCh)) {
-						const [error, _] = this.handleNumber(component);
-						if (error) return err(error.type, error.message);
-					} else return err("CronExpressionError", `Invalid cron expression '${this.expression}' in field '${field}'`);
+					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 ok(true);
+		return true;
 	}
 	addToken(component, type, value, field) {
 		const token = new Token(component, type, value, field);
@@ -317,12 +342,12 @@ var Scanner = class {
 			this.advance(content);
 			ch = this.peek(content);
 		}
-		if (ch && ch !== ",") return err("CronExpressionError", `Invalid step expression '${content}' for field '${field}'`);
+		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) return err("CronExpressionError", `Invalid step expression '${content}' for field '${field}'`);
+		if (value.length === 0) throw new CronExpressionError(`Invalid step expression '${content}' for field '${field}'`);
 		this.addToken(tokenContent, "step", Number(value), field);
-		return ok(true);
+		return true;
 	}
 	handleRangeWithStep(component) {
 		const { field, content } = component;
@@ -331,13 +356,12 @@ var Scanner = class {
 			this.advance(content);
 			ch = this.peek(content);
 		}
-		if (!ch) return err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+		if (!ch) throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
 		if (this.match(content, "/")) {
-			const [error, _] = this.handleStep(component);
-			if (error) return err(error.type, error.message);
-			return ok(true);
+			this.handleStep(component);
+			return true;
 		}
-		return err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+		throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
 	}
 	handleNumber(component) {
 		const { field, content } = component;
@@ -350,27 +374,25 @@ var Scanner = class {
 		if (!ch) {
 			const item = content.substring(this.start);
 			this.addToken(item, "number", Number(item), field);
-			return ok(true);
+			return true;
 		}
 		if (this.match(content, "-")) {
-			const [error, _] = this.handleRange(component);
-			if (error) return err(error.type, error.message);
-			return ok(true);
+			this.handleRange(component);
+			return true;
 		}
 		if (this.match(content, "/")) {
-			const [error, _] = this.handleStep(component);
-			if (error) return err(error.type, error.message);
-			return ok(true);
+			this.handleStep(component);
+			return true;
 		}
-		if (!this.isDigit(ch) && ch !== ",") return err("CronExpressionError", `Invalid number '${content}' for field '${field}'`);
+		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 ok(true);
+		return true;
 	}
 	handleRange(component) {
 		const { field, content } = component;
 		let ch = this.peek(content);
-		if (!ch) return err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+		if (!ch) throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
 		while (ch && this.isDigit(ch)) {
 			this.advance(content);
 			ch = this.peek(content);
@@ -378,17 +400,16 @@ var Scanner = class {
 		if (!ch) {
 			const tokenContent = content.substring(this.start);
 			this.addToken(tokenContent, "range", tokenContent, field);
-			return ok(true);
+			return true;
 		}
 		if (this.match(content, "/")) {
-			const [error, _] = this.handleStep(component);
-			if (error) return err(error.type, error.message);
-			return ok(true);
+			this.handleStep(component);
+			return true;
 		}
-		if (ch && ch !== ",") return err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+		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 ok(true);
+		return true;
 	}
 	isDigit(ch) {
 		return ch >= "0" && ch <= "9";
@@ -471,70 +492,67 @@ var Cron = class {
 	}
 	handleStep(part, values, min, max) {
 		const [rangePart, stepStr] = part.split("/");
-		if (!rangePart) return err("InvalidValueError", `'${rangePart}' is empty`);
-		if (!stepStr) return err("InvalidValueError", `'${stepStr}' is empty`);
+		if (!rangePart) throw new InvalidValueError(`'${rangePart}' is empty`);
+		if (!stepStr) throw new InvalidValueError(`'${stepStr}' is empty`);
 		const step = Number(stepStr);
-		if (!Number.isInteger(step)) return err("InvalidValueError", `'${step}' is not a valid number`);
-		if (step <= 0) return err("OutOfBoundError", `Expected ${step} > 0`);
+		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 ok(true);
+			return;
 		}
-		if (rangePart.includes("-")) return this.handleStepRange(rangePart, step, values, min, max);
-		return this.handleStepSingle(rangePart, step, values, min, max);
+		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) return err("InvalidValueError", `'${endStr}' is empty`);
+		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)) return err("InvalidValueError", `'${start}' is not a valid number`);
-		if (!Number.isInteger(end)) return err("InvalidValueError", `'${end}' is not a valid number`);
-		if (start < min) return err("OutOfBoundError", `Expected ${start} >= ${min}`);
-		if (end > max) return err("OutOfBoundError", `Expected ${end} <= ${max}`);
-		if (start > end) return err("OutOfBoundError", `Expected ${start} <= ${end}`);
+		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;
-		return ok(true);
 	}
 	handleStepSingle(value, step, values, min, max) {
 		const start = Number(value);
-		if (!Number.isInteger(start)) return err("InvalidValueError", `'${start}' is not a valid number`);
-		if (start < min) return err("OutOfBoundError", `Expected ${start} >= ${min}`);
-		if (start > max) return err("OutOfBoundError", `Expected ${start} <= ${max}`);
+		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;
-		return ok(true);
 	}
 	handleRange(part, values, min, max) {
 		const [startStr, endStr] = part.split("-");
-		if (!startStr) return err("InvalidValueError", `'${startStr}' is empty`);
-		if (!endStr) return err("InvalidValueError", `'${endStr}' is empty`);
+		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)) return err("InvalidValueError", `'${start}' is not a valid number`);
-		if (!Number.isInteger(end)) return err("InvalidValueError", `'${end}' is not a valid number`);
-		if (start < min) return err("OutOfBoundError", `Expected ${start} >= ${min}`);
-		if (end > max) return err("OutOfBoundError", `Expected ${end} <= ${max}`);
-		if (start > end) return err("OutOfBoundError", `Expected ${start} <= ${end}`);
+		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;
-		return ok(true);
 	}
 	handleNumber(value, values, min, max) {
 		const n = Number(value);
-		if (!Number.isInteger(n)) return err("InvalidValueError", `'${value}' is not a valid number`);
-		if (n < min) return err("OutOfBoundError", `Expected ${n} >= ${min}`);
-		if (n > max) return err("OutOfBoundError", `Expected ${n} <= ${max}`);
+		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;
-		return ok(true);
 	}
 	constructor(options) {
 		this.options = options;
 		const expr = this.resolveAlias(options.schedule);
-		const [error, tokens] = new Scanner(expr).scan();
-		if (error) throw new Error(`${error.type}: ${error.message}`);
+		const tokens = new Scanner(expr).scan();
 		this.hasSeconds = expr.trim().split(/\s+/).length === FieldAmount.max;
-		const [parsingError, _] = this.parse(tokens);
-		if (parsingError) throw new Error(`${parsingError.type}: ${parsingError.message}`);
+		this.parse(tokens);
 	}
 	resolveAlias(schedule) {
 		return ALIASES[schedule] || schedule;
@@ -542,71 +560,53 @@ var Cron = class {
 	parse(tokens) {
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
-			if (!token) return err("InvalidValueError", "Undefined token");
+			if (!token) throw new InvalidValueError("Undefined token");
 			const tokenType = token.getTokenType();
 			switch (token.getField()) {
-				case "second": {
-					const [error, _] = this.handleField(token, this.second, CronSecondRange.min, CronSecondRange.max);
-					if (error) return err(error.type, `${error.message} in field '${token.getField()}'`);
+				case "second":
+					this.handleField(token, this.second, CronSecondRange.min, CronSecondRange.max);
 					break;
-				}
-				case "minute": {
-					const [error, _] = this.handleField(token, this.minute, CronMinuteRange.min, CronMinuteRange.max);
-					if (error) return err(error.type, `${error.message} in field '${token.getField()}'`);
+				case "minute":
+					this.handleField(token, this.minute, CronMinuteRange.min, CronMinuteRange.max);
 					break;
-				}
-				case "hour": {
-					const [error, _] = this.handleField(token, this.hour, CronHourRange.min, CronHourRange.max);
-					if (error) return err(error.type, `${error.message} in field '${token.getField()}'`);
+				case "hour":
+					this.handleField(token, this.hour, CronHourRange.min, CronHourRange.max);
 					break;
-				}
-				case "day": {
+				case "day":
 					if (tokenType === "any") this._dayWildcard = true;
-					const [error, _] = this.handleField(token, this.day, CronDayRange.min, CronDayRange.max);
-					if (error) return err(error.type, `${error.message} in field '${token.getField()}'`);
+					this.handleField(token, this.day, CronDayRange.min, CronDayRange.max);
 					break;
-				}
-				case "month": {
-					const [error, _] = this.handleField(token, this.month, CronMonthRange.min, CronMonthRange.max);
-					if (error) return err(error.type, `${error.message} in field '${token.getField()}'`);
+				case "month":
+					this.handleField(token, this.month, CronMonthRange.min, CronMonthRange.max);
 					break;
-				}
-				case "weekday": {
+				case "weekday":
 					if (tokenType === "any") this._dowWildcard = true;
-					const [error, _] = this.handleField(token, this.dayOfWeek, CronDayOfWeekRange.min, CronDayOfWeekRange.max);
-					if (error) return err(error.type, `${error.message} in field '${token.getField()}'`);
+					this.handleField(token, this.dayOfWeek, CronDayOfWeekRange.min, CronDayOfWeekRange.max);
 					break;
-				}
-				default: return err("InvalidValueError", `Invalid field '${token.getField()}'`);
+				default: throw new InvalidValueError(`Invalid field '${token.getField()}'`);
 			}
 		}
-		return ok(true);
 	}
 	handleField(token, field, min, max) {
 		switch (token.getTokenType()) {
 			case "any":
 				this.fillRange(field, min, max);
 				break;
-			case "number": {
-				const [error, _] = this.handleNumber(token.getComponent(), field, min, max);
-				if (error) return err(error.type, error.message);
+			case "number":
+				this.handleNumber(token.getComponent(), field, min, max);
 				break;
-			}
 			case "range": {
 				const component = token.getComponent();
-				const [error, _] = this.handleRange(component, field, min, max);
-				if (error) return err(error.type, error.message);
+				this.handleRange(component, field, min, max);
 				break;
 			}
 			case "step": {
 				const component = token.getComponent();
-				const [error, _] = this.handleStep(component, field, min, max);
-				if (error) return err(error.type, error.message);
+				this.handleStep(component, field, min, max);
 				break;
 			}
-			default: return err("InvalidValueError", `Invalid token type '${token.getTokenType()}'`);
+			default: throw new InvalidValueError(`Invalid token type '${token.getTokenType()}'`);
 		}
-		return ok(true);
 	}
 	matches(date) {
 		const s = date.getSeconds();

package/dist/lib/errors/index.d.cts

@@ -1,2 +1,13 @@
-import { i as ok, n as mightThrow, r as mightThrowSync, t as err } from "../../index-DxSbeGP-.cjs";
+//#region src/lib/errors/types.d.ts
+type CommonError = "NotFoundError" | "UnauthorizedError" | "InternalServerError" | "ValidationError" | "MigrationError" | "SchemaError" | (string & {});
+//#endregion
+//#region src/lib/errors/index.d.ts
+declare const ok: <T>(data: T) => readonly [null, T];
+declare const err: <T extends CommonError>(type: T, message: string) => readonly [{
+  readonly type: T;
+  readonly message: string;
+}, null];
+declare const mightThrowSync: <T, E = Error>(fn: () => T) => readonly [null, T] | readonly [E, null];
+declare const mightThrow: <T, E = Error>(promise: Promise<T>) => Promise<readonly [null, T] | readonly [E, null]>;
+//#endregion
 export { err, mightThrow, mightThrowSync, ok };

package/dist/lib/errors/index.d.mts

@@ -1,2 +1,13 @@
-import { i as ok, n as mightThrow, r as mightThrowSync, t as err } from "../../index-BhGNDjPq.mjs";
+//#region src/lib/errors/types.d.ts
+type CommonError = "NotFoundError" | "UnauthorizedError" | "InternalServerError" | "ValidationError" | "MigrationError" | "SchemaError" | (string & {});
+//#endregion
+//#region src/lib/errors/index.d.ts
+declare const ok: <T>(data: T) => readonly [null, T];
+declare const err: <T extends CommonError>(type: T, message: string) => readonly [{
+  readonly type: T;
+  readonly message: string;
+}, null];
+declare const mightThrowSync: <T, E = Error>(fn: () => T) => readonly [null, T] | readonly [E, null];
+declare const mightThrow: <T, E = Error>(promise: Promise<T>) => Promise<readonly [null, T] | readonly [E, null]>;
+//#endregion
 export { err, mightThrow, mightThrowSync, ok };

package/dist/lib/logging/index.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../chunk-CKQMccvm.cjs");
 const require_lib_errors_index = require("../errors/index.cjs");
 let node_path = require("node:path");
 let node_fs = require("node:fs");