@beabee/beabee-common 1.6.1 → 1.7.0

package/dist/cjs/search/index.js

@@ -86,10 +86,27 @@ function validateRule(filters, rule) {
     if (operator.args !== rule.value.length) {
         return false; // Invalid number of args
     }
-    return true;
+    const expectedType = filter.type === "boolean" || filter.type === "number"
+        ? filter.type
+        : "string";
+    if (rule.value.some((v) => typeof v !== expectedType)) {
+        return false; // Invalid value type
+    }
+    if (filter.type === "date" &&
+        rule.value.some((v) => isNaN(+new Date(v)))) {
+        return false; // Invalid date
+    }
+    return {
+        ...rule,
+        type: filter.type,
+    };
 }
 exports.validateRule = validateRule;
 function validateRuleGroup(filters, ruleGroup) {
+    const validatedRuleGroup = {
+        condition: ruleGroup.condition,
+        rules: [],
+    };
     for (const rule of ruleGroup.rules) {
         const valid = isRuleGroup(rule)
             ? validateRuleGroup(filters, rule)
@@ -97,8 +114,9 @@ function validateRuleGroup(filters, ruleGroup) {
         if (!valid) {
             return false;
         }
+        validatedRuleGroup.rules.push(valid);
     }
-    return true;
+    return validatedRuleGroup;
 }
 exports.validateRuleGroup = validateRuleGroup;
 function convertRuleGroupToFilters(ruleGroup) {

package/dist/esm/search/index.js

@@ -68,9 +68,26 @@ export function validateRule(filters, rule) {
     if (operator.args !== rule.value.length) {
         return false; // Invalid number of args
     }
-    return true;
+    const expectedType = filter.type === "boolean" || filter.type === "number"
+        ? filter.type
+        : "string";
+    if (rule.value.some((v) => typeof v !== expectedType)) {
+        return false; // Invalid value type
+    }
+    if (filter.type === "date" &&
+        rule.value.some((v) => isNaN(+new Date(v)))) {
+        return false; // Invalid date
+    }
+    return {
+        ...rule,
+        type: filter.type,
+    };
 }
 export function validateRuleGroup(filters, ruleGroup) {
+    const validatedRuleGroup = {
+        condition: ruleGroup.condition,
+        rules: [],
+    };
     for (const rule of ruleGroup.rules) {
         const valid = isRuleGroup(rule)
             ? validateRuleGroup(filters, rule)
@@ -78,8 +95,9 @@ export function validateRuleGroup(filters, ruleGroup) {
         if (!valid) {
             return false;
         }
+        validatedRuleGroup.rules.push(valid);
     }
-    return true;
+    return validatedRuleGroup;
 }
 export function convertRuleGroupToFilters(ruleGroup) {
     if (!ruleGroup) {

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

@@ -1,14 +1,28 @@
 export declare const ruleOperators: readonly ["equal", "not_equal", "less", "less_or_equal", "greater", "greater_or_equal", "between", "not_between", "begins_with", "not_begins_with", "contains", "not_contains", "ends_with", "not_ends_with", "is_empty", "is_not_empty"];
 export declare type RuleOperator = typeof ruleOperators[number];
 export declare type RuleValue = string | number | boolean;
-export interface Rule<Field extends string> {
-    field: Field;
+export interface Rule {
+    field: string;
     operator: RuleOperator;
     value: RuleValue[];
 }
-export interface RuleGroup<Field extends string> {
+export interface RuleGroup {
     condition: "AND" | "OR";
-    rules: (RuleGroup<Field> | Rule<Field>)[];
+    rules: (RuleGroup | Rule)[];
+}
+interface BaseValidatedRule<T extends FilterType, F extends string, V> {
+    type: T;
+    field: F;
+    operator: keyof typeof operatorsByType[T];
+    value: V[];
+}
+declare type ValidatedNumberRule<Field extends string> = BaseValidatedRule<"number", Field, number>;
+declare type ValidatedStringRule<Field extends string> = BaseValidatedRule<Exclude<FilterType, "number" | "boolean">, Field, string>;
+declare type ValidatedBooleanRule<Field extends string> = BaseValidatedRule<"boolean", Field, boolean>;
+export declare type ValidatedRule<Field extends string> = ValidatedNumberRule<Field> | ValidatedStringRule<Field> | ValidatedBooleanRule<Field>;
+export interface ValidatedRuleGroup<Field extends string> {
+    condition: "AND" | "OR";
+    rules: (ValidatedRuleGroup<Field> | ValidatedRule<Field>)[];
 }
 export declare type FilterType = "text" | "date" | "number" | "boolean" | "array" | "enum" | "contact";
 export declare type FilterValue = RuleValue;
@@ -24,7 +38,115 @@ export declare const nullableOperators: {
         args: number;
     };
 };
-export declare const operatorsByType: Record<FilterType, Partial<Record<FilterOperator, FilterOperatorParams>>>;
+export declare const operatorsByType: {
+    readonly text: {
+        readonly begins_with: {
+            readonly args: 1;
+        };
+        readonly ends_with: {
+            readonly args: 1;
+        };
+        readonly not_begins_with: {
+            readonly args: 1;
+        };
+        readonly not_ends_with: {
+            readonly args: 1;
+        };
+        readonly contains: {
+            args: number;
+        };
+        readonly not_contains: {
+            args: number;
+        };
+        readonly equal: {
+            args: number;
+        };
+        readonly not_equal: {
+            args: number;
+        };
+    };
+    readonly date: {
+        between: {
+            args: number;
+        };
+        not_between: {
+            args: number;
+        };
+        less: {
+            args: number;
+        };
+        greater: {
+            args: number;
+        };
+        less_or_equal: {
+            args: number;
+        };
+        greater_or_equal: {
+            args: number;
+        };
+        equal: {
+            args: number;
+        };
+        not_equal: {
+            args: number;
+        };
+    };
+    readonly number: {
+        between: {
+            args: number;
+        };
+        not_between: {
+            args: number;
+        };
+        less: {
+            args: number;
+        };
+        greater: {
+            args: number;
+        };
+        less_or_equal: {
+            args: number;
+        };
+        greater_or_equal: {
+            args: number;
+        };
+        equal: {
+            args: number;
+        };
+        not_equal: {
+            args: number;
+        };
+    };
+    readonly boolean: {
+        readonly equal: {
+            args: number;
+        };
+    };
+    readonly array: {
+        contains: {
+            args: number;
+        };
+        not_contains: {
+            args: number;
+        };
+    };
+    readonly enum: {
+        equal: {
+            args: number;
+        };
+        not_equal: {
+            args: number;
+        };
+    };
+    readonly contact: {
+        equal: {
+            args: number;
+        };
+        not_equal: {
+            args: number;
+        };
+    };
+};
 interface BaseFilterArgs {
     type: FilterType;
     nullable?: boolean;
@@ -49,18 +171,18 @@ export interface Paginated<T> {
     count: number;
     total: number;
 }
-export interface PaginatedQuery<Field extends string> {
+export interface PaginatedQuery {
     limit?: number;
     offset?: number;
     sort?: string;
     order?: "ASC" | "DESC";
-    rules?: RuleGroup<Field>;
+    rules?: RuleGroup;
 }
-export declare function isRuleGroup<Field extends string>(ruleOrGroup: Rule<Field> | RuleGroup<Field>): ruleOrGroup is RuleGroup<Field>;
-export declare function validateRule<Field extends string>(filters: Filters<Field>, rule: Rule<string>): rule is Rule<Field>;
-export declare function validateRuleGroup<Field extends string>(filters: Filters<Field>, ruleGroup: RuleGroup<string>): ruleGroup is RuleGroup<Field>;
-export declare function convertRuleGroupToFilters(ruleGroup?: RuleGroup<string>): Filter[] | null;
-export declare function convertFiltersToRuleGroup(matchType: "all" | "any", filters: Filter[]): RuleGroup<string>;
+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 function convertRuleGroupToFilters(ruleGroup?: RuleGroup): Filter[] | null;
+export declare function convertFiltersToRuleGroup(matchType: "all" | "any", filters: Filter[]): RuleGroup;
 export * from "./callouts";
 export * from "./contacts";
 export * from "./notices";

package/package.json

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