@beabee/beabee-common 1.7.4 → 1.8.1

package/dist/cjs/search/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertFiltersToRuleGroup = exports.convertRuleGroupToFilters = exports.validateRuleGroup = exports.validateRule = exports.isRuleGroup = exports.operatorsByType = exports.nullableOperators = exports.ruleOperators = void 0;
+exports.convertFiltersToRuleGroup = exports.convertRuleGroupToFilters = exports.validateRuleGroup = exports.validateRule = exports.InvalidRule = exports.isRuleGroup = exports.operatorsByType = exports.nullableOperators = exports.ruleOperators = void 0;
 const isValid_1 = __importDefault(require("date-fns/isValid"));
 const parseISO_1 = __importDefault(require("date-fns/parseISO"));
 // *** Definitions for rules ***
@@ -84,37 +84,47 @@ function isRuleGroup(ruleOrGroup) {
     return "condition" in ruleOrGroup;
 }
 exports.isRuleGroup = isRuleGroup;
+class InvalidRule extends Error {
+    constructor(rule, message) {
+        super();
+        this.rule = rule;
+        this.message = message;
+        Object.setPrototypeOf(this, InvalidRule.prototype);
+    }
+}
+exports.InvalidRule = InvalidRule;
 function validateRule(filters, rule) {
     const filter = filters[rule.field];
     if (!filter) {
-        return false; // Invalid field
+        throw new InvalidRule(rule, `Invalid field: ${rule.field}`);
     }
     if (rule.operator in exports.nullableOperators) {
+        // Field cannot be empty (except text which can always be empty)
         if (!filter.nullable && filter.type !== "text") {
-            return false; // Field cannot be empty (text can always be empty)
+            throw new InvalidRule(rule, `Invalid nullable operator: field is not nullable`);
         }
         if (rule.value.length !== 0) {
-            return false; // Should have no args
+            throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs 0, ${rule.value.length} given`);
         }
     }
     else {
         const operator = operatorsByTypeMap[filter.type][rule.operator];
         if (!operator) {
-            return false; // Invalid operator
+            throw new InvalidRule(rule, `Invalid operator for type: ${filter.type} type doesn't define ${rule.operator}`);
         }
         if (operator.args !== rule.value.length) {
-            return false; // Invalid number of args
+            throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs ${operator.args}, ${rule.value.length} given`);
         }
     }
     const expectedType = filter.type === "boolean" || filter.type === "number"
         ? filter.type
         : "string";
     if (rule.value.some((v) => typeof v !== expectedType)) {
-        return false; // Invalid value type
+        throw new InvalidRule(rule, `Invalid operator argument type: ${rule.operator} needs ${expectedType}, ${rule.value.map((v) => typeof v)} given`);
     }
     if (filter.type === "date" &&
         rule.value.some((v) => !(0, isValid_1.default)((0, parseISO_1.default)(v)))) {
-        return false; // Invalid date
+        throw new InvalidRule(rule, `Invalid operator argument: date type needs valid absolute or relative date, ${rule.value} given`);
     }
     return {
         ...rule,
@@ -131,9 +141,6 @@ function validateRuleGroup(filters, ruleGroup) {
         const valid = isRuleGroup(rule)
             ? validateRuleGroup(filters, rule)
             : validateRule(filters, rule);
-        if (!valid) {
-            return false;
-        }
         validatedRuleGroup.rules.push(valid);
     }
     return validatedRuleGroup;

package/dist/esm/search/index.js

@@ -63,37 +63,46 @@ const operatorsByTypeMap = operatorsByType;
 export function isRuleGroup(ruleOrGroup) {
     return "condition" in ruleOrGroup;
 }
+export class InvalidRule extends Error {
+    constructor(rule, message) {
+        super();
+        this.rule = rule;
+        this.message = message;
+        Object.setPrototypeOf(this, InvalidRule.prototype);
+    }
+}
 export function validateRule(filters, rule) {
     const filter = filters[rule.field];
     if (!filter) {
-        return false; // Invalid field
+        throw new InvalidRule(rule, `Invalid field: ${rule.field}`);
     }
     if (rule.operator in nullableOperators) {
+        // Field cannot be empty (except text which can always be empty)
         if (!filter.nullable && filter.type !== "text") {
-            return false; // Field cannot be empty (text can always be empty)
+            throw new InvalidRule(rule, `Invalid nullable operator: field is not nullable`);
         }
         if (rule.value.length !== 0) {
-            return false; // Should have no args
+            throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs 0, ${rule.value.length} given`);
         }
     }
     else {
         const operator = operatorsByTypeMap[filter.type][rule.operator];
         if (!operator) {
-            return false; // Invalid operator
+            throw new InvalidRule(rule, `Invalid operator for type: ${filter.type} type doesn't define ${rule.operator}`);
         }
         if (operator.args !== rule.value.length) {
-            return false; // Invalid number of args
+            throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs ${operator.args}, ${rule.value.length} given`);
         }
     }
     const expectedType = filter.type === "boolean" || filter.type === "number"
         ? filter.type
         : "string";
     if (rule.value.some((v) => typeof v !== expectedType)) {
-        return false; // Invalid value type
+        throw new InvalidRule(rule, `Invalid operator argument type: ${rule.operator} needs ${expectedType}, ${rule.value.map((v) => typeof v)} given`);
     }
     if (filter.type === "date" &&
         rule.value.some((v) => !isValid(parseISO(v)))) {
-        return false; // Invalid date
+        throw new InvalidRule(rule, `Invalid operator argument: date type needs valid absolute or relative date, ${rule.value} given`);
     }
     return {
         ...rule,
@@ -109,9 +118,6 @@ export function validateRuleGroup(filters, ruleGroup) {
         const valid = isRuleGroup(rule)
             ? validateRuleGroup(filters, rule)
             : validateRule(filters, rule);
-        if (!valid) {
-            return false;
-        }
         validatedRuleGroup.rules.push(valid);
     }
     return validatedRuleGroup;

package/dist/types/search/index.d.ts

@@ -179,8 +179,13 @@ export interface PaginatedQuery {
     rules?: RuleGroup;
 }
 export declare function isRuleGroup(ruleOrGroup: Rule | RuleGroup): ruleOrGroup is RuleGroup;
-export declare function validateRule<Field extends string>(filters: Filters<Field>, rule: Rule): ValidatedRule<Field> | false;
-export declare function validateRuleGroup<Field extends string>(filters: Filters<Field>, ruleGroup: RuleGroup): ValidatedRuleGroup<Field> | false;
+export declare class InvalidRule extends Error {
+    readonly rule: Rule;
+    readonly message: string;
+    constructor(rule: Rule, message: string);
+}
+export declare function validateRule<Field extends string>(filters: Filters<Field>, rule: Rule): ValidatedRule<Field>;
+export declare function validateRuleGroup<Field extends string>(filters: Filters<Field>, ruleGroup: RuleGroup): ValidatedRuleGroup<Field>;
 export declare function convertRuleGroupToFilters(ruleGroup?: RuleGroup): Filter[] | null;
 export declare function convertFiltersToRuleGroup(matchType: "all" | "any", filters: Filter[]): RuleGroup;
 export * from "./callouts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beabee/beabee-common",
-  "version": "1.7.4",
+  "version": "1.8.1",
   "description": "",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",