@beabee/beabee-common 1.10.2 → 1.10.4

package/dist/cjs/search/callouts.js

@@ -31,6 +31,7 @@ exports.calloutFilters = {
 exports.calloutResponseFilters = {
     contact: {
         type: "contact",
+        nullable: true,
     },
     callout: {
         type: "text",
@@ -41,4 +42,8 @@ exports.calloutResponseFilters = {
     updatedAt: {
         type: "date",
     },
+    answers: {
+        type: "custom",
+        nullable: true,
+    },
 };

package/dist/cjs/search/index.js

@@ -38,6 +38,12 @@ const equalityOperators = {
     equal: { args: 1 },
     not_equal: { args: 1 },
 };
+const stringOperators = {
+    begins_with: { args: 1 },
+    ends_with: { args: 1 },
+    not_begins_with: { args: 1 },
+    not_ends_with: { args: 1 },
+};
 const numericOperators = {
     ...equalityOperators,
     between: { args: 2 },
@@ -57,20 +63,19 @@ exports.nullableOperators = {
     is_not_empty: { args: 0 },
 };
 exports.operatorsByType = {
-    text: {
-        ...equalityOperators,
-        ...arrayOperators,
-        begins_with: { args: 1 },
-        ends_with: { args: 1 },
-        not_begins_with: { args: 1 },
-        not_ends_with: { args: 1 },
-    },
+    text: { ...equalityOperators, ...arrayOperators, ...stringOperators },
     date: numericOperators,
     number: numericOperators,
     boolean: { equal: equalityOperators.equal },
     array: arrayOperators,
     enum: equalityOperators,
     contact: equalityOperators,
+    custom: {
+        ...equalityOperators,
+        ...arrayOperators,
+        ...stringOperators,
+        ...numericOperators,
+    },
 };
 // More general type to allow mapping while maintaining full type above
 exports.operatorsByTypeMap = exports.operatorsByType;

package/dist/cjs/utils/date.js

@@ -31,7 +31,7 @@ const startOf = {
     m: startOfMinute_1.default,
     s: startOfSecond_1.default,
 };
-const relativeDate = /\$now(?<units>\(((y|M|d|h|m|s):(-?\d+),?)+\))?/;
+const relativeDate = /^\$now(?<units>\(((y|M|d|h|m|s):(-?\d+),?)+\))?$/;
 const relativeUnit = /(y|M|d|h|m|s):(-?\d+)/g;
 // Matches the different parts of an ISO 8601 date. Note we don't validate the
 // pattern properly as that is handled by parseISO, we just want to know which

package/dist/cjs/utils/rules.js

@@ -9,27 +9,27 @@ function isRuleGroup(ruleOrGroup) {
 }
 exports.isRuleGroup = isRuleGroup;
 function validateRule(filters, rule) {
-    const filter = filters[rule.field];
+    const [fieldName, fieldParam] = rule.field.split(".", 2);
+    const filter = filters[fieldName];
     if (!filter) {
         throw new error_1.InvalidRule(rule, `Invalid field: ${rule.field}`);
     }
+    let expectedArgs = 0;
     if (rule.operator in search_1.nullableOperators) {
         // Field cannot be empty (except text which can always be empty)
         if (!filter.nullable && filter.type !== "text") {
             throw new error_1.InvalidRule(rule, `Invalid nullable operator: field is not nullable`);
         }
-        if (rule.value.length !== 0) {
-            throw new error_1.InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs 0, ${rule.value.length} given`);
-        }
     }
     else {
         const operator = search_1.operatorsByTypeMap[filter.type][rule.operator];
         if (!operator) {
             throw new error_1.InvalidRule(rule, `Invalid operator for type: ${filter.type} type doesn't define ${rule.operator}`);
         }
-        if (operator.args !== rule.value.length) {
-            throw new error_1.InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs ${operator.args}, ${rule.value.length} given`);
-        }
+        expectedArgs = operator.args;
+    }
+    if (expectedArgs !== rule.value.length) {
+        throw new error_1.InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs ${expectedArgs}, ${rule.value.length} given`);
     }
     const expectedType = filter.type === "boolean" || filter.type === "number"
         ? filter.type
@@ -42,8 +42,11 @@ function validateRule(filters, rule) {
         throw new error_1.InvalidRule(rule, `Invalid operator argument: date type needs valid absolute or relative date, ${rule.value} given`);
     }
     return {
-        ...rule,
+        field: fieldName,
+        param: fieldParam,
         type: filter.type,
+        operator: rule.operator,
+        value: rule.value,
     };
 }
 exports.validateRule = validateRule;

package/dist/esm/search/callouts.js

@@ -28,6 +28,7 @@ export const calloutFilters = {
 export const calloutResponseFilters = {
     contact: {
         type: "contact",
+        nullable: true,
     },
     callout: {
         type: "text",
@@ -38,4 +39,8 @@ export const calloutResponseFilters = {
     updatedAt: {
         type: "date",
     },
+    answers: {
+        type: "custom",
+        nullable: true,
+    },
 };

package/dist/esm/search/index.js

@@ -21,6 +21,12 @@ const equalityOperators = {
     equal: { args: 1 },
     not_equal: { args: 1 },
 };
+const stringOperators = {
+    begins_with: { args: 1 },
+    ends_with: { args: 1 },
+    not_begins_with: { args: 1 },
+    not_ends_with: { args: 1 },
+};
 const numericOperators = {
     ...equalityOperators,
     between: { args: 2 },
@@ -40,20 +46,19 @@ export const nullableOperators = {
     is_not_empty: { args: 0 },
 };
 export const operatorsByType = {
-    text: {
-        ...equalityOperators,
-        ...arrayOperators,
-        begins_with: { args: 1 },
-        ends_with: { args: 1 },
-        not_begins_with: { args: 1 },
-        not_ends_with: { args: 1 },
-    },
+    text: { ...equalityOperators, ...arrayOperators, ...stringOperators },
     date: numericOperators,
     number: numericOperators,
     boolean: { equal: equalityOperators.equal },
     array: arrayOperators,
     enum: equalityOperators,
     contact: equalityOperators,
+    custom: {
+        ...equalityOperators,
+        ...arrayOperators,
+        ...stringOperators,
+        ...numericOperators,
+    },
 };
 // More general type to allow mapping while maintaining full type above
 export const operatorsByTypeMap = operatorsByType;

package/dist/esm/utils/date.js

@@ -25,7 +25,7 @@ const startOf = {
     m: startOfMinute,
     s: startOfSecond,
 };
-const relativeDate = /\$now(?<units>\(((y|M|d|h|m|s):(-?\d+),?)+\))?/;
+const relativeDate = /^\$now(?<units>\(((y|M|d|h|m|s):(-?\d+),?)+\))?$/;
 const relativeUnit = /(y|M|d|h|m|s):(-?\d+)/g;
 // Matches the different parts of an ISO 8601 date. Note we don't validate the
 // pattern properly as that is handled by parseISO, we just want to know which

package/dist/esm/utils/rules.js

@@ -5,27 +5,27 @@ export function isRuleGroup(ruleOrGroup) {
     return "condition" in ruleOrGroup;
 }
 export function validateRule(filters, rule) {
-    const filter = filters[rule.field];
+    const [fieldName, fieldParam] = rule.field.split(".", 2);
+    const filter = filters[fieldName];
     if (!filter) {
         throw new InvalidRule(rule, `Invalid field: ${rule.field}`);
     }
+    let expectedArgs = 0;
     if (rule.operator in nullableOperators) {
         // Field cannot be empty (except text which can always be empty)
         if (!filter.nullable && filter.type !== "text") {
             throw new InvalidRule(rule, `Invalid nullable operator: field is not nullable`);
         }
-        if (rule.value.length !== 0) {
-            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) {
             throw new InvalidRule(rule, `Invalid operator for type: ${filter.type} type doesn't define ${rule.operator}`);
         }
-        if (operator.args !== rule.value.length) {
-            throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs ${operator.args}, ${rule.value.length} given`);
-        }
+        expectedArgs = operator.args;
+    }
+    if (expectedArgs !== rule.value.length) {
+        throw new InvalidRule(rule, `Invalid operator argument count: ${rule.operator} needs ${expectedArgs}, ${rule.value.length} given`);
     }
     const expectedType = filter.type === "boolean" || filter.type === "number"
         ? filter.type
@@ -38,8 +38,11 @@ export function validateRule(filters, rule) {
         throw new InvalidRule(rule, `Invalid operator argument: date type needs valid absolute or relative date, ${rule.value} given`);
     }
     return {
-        ...rule,
+        field: fieldName,
+        param: fieldParam,
         type: filter.type,
+        operator: rule.operator,
+        value: rule.value,
     };
 }
 export function validateRuleGroup(filters, ruleGroup) {

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

@@ -40,4 +40,4 @@ export declare enum PaymentStatus {
     Cancelled = "cancelled"
 }
 export declare const RoleTypes: readonly ["member", "admin", "superadmin"];
-export declare type RoleType = typeof RoleTypes[number];
+export type RoleType = (typeof RoleTypes)[number];

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

@@ -1,38 +1,43 @@
 import { ItemStatus } from "../data";
 export declare const calloutFilters: {
-    readonly title: {
-        readonly type: "text";
+    title: {
+        type: "text";
     };
-    readonly status: {
-        readonly type: "enum";
-        readonly options: readonly [ItemStatus.Draft, ItemStatus.Scheduled, ItemStatus.Open, ItemStatus.Ended];
+    status: {
+        type: "enum";
+        options: ItemStatus[];
     };
-    readonly answeredBy: {
-        readonly type: "contact";
+    answeredBy: {
+        type: "contact";
     };
-    readonly starts: {
-        readonly type: "date";
+    starts: {
+        type: "date";
     };
-    readonly expires: {
-        readonly type: "date";
+    expires: {
+        type: "date";
     };
-    readonly hidden: {
-        readonly type: "boolean";
+    hidden: {
+        type: "boolean";
     };
 };
-export declare type CalloutFilterName = keyof typeof calloutFilters;
+export type CalloutFilterName = keyof typeof calloutFilters;
 export declare const calloutResponseFilters: {
-    readonly contact: {
-        readonly type: "contact";
+    contact: {
+        type: "contact";
+        nullable: true;
     };
-    readonly callout: {
-        readonly type: "text";
+    callout: {
+        type: "text";
     };
-    readonly createdAt: {
-        readonly type: "date";
+    createdAt: {
+        type: "date";
     };
-    readonly updatedAt: {
-        readonly type: "date";
+    updatedAt: {
+        type: "date";
+    };
+    answers: {
+        type: "custom";
+        nullable: true;
     };
 };
-export declare type CalloutResponseFilterName = keyof typeof calloutResponseFilters;
+export type CalloutResponseFilterName = keyof typeof calloutResponseFilters;

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

@@ -1,61 +1,61 @@
 import { ContributionPeriod, ContributionType, NewsletterStatus } from "../data";
 export declare const contactFilters: {
-    readonly firstname: {
-        readonly type: "text";
+    firstname: {
+        type: "text";
     };
-    readonly lastname: {
-        readonly type: "text";
+    lastname: {
+        type: "text";
     };
-    readonly email: {
-        readonly type: "text";
+    email: {
+        type: "text";
     };
-    readonly joined: {
-        readonly type: "date";
+    joined: {
+        type: "date";
     };
-    readonly lastSeen: {
-        readonly type: "date";
+    lastSeen: {
+        type: "date";
     };
-    readonly contributionCancelled: {
-        readonly type: "date";
+    contributionCancelled: {
+        type: "date";
     };
-    readonly contributionType: {
-        readonly type: "enum";
-        readonly options: readonly [ContributionType.Automatic, ContributionType.Gift, ContributionType.Manual, ContributionType.None];
+    contributionType: {
+        type: "enum";
+        options: ContributionType[];
     };
-    readonly contributionMonthlyAmount: {
-        readonly type: "number";
+    contributionMonthlyAmount: {
+        type: "number";
     };
-    readonly contributionPeriod: {
-        readonly type: "enum";
-        readonly options: readonly [ContributionPeriod.Monthly, ContributionPeriod.Annually];
+    contributionPeriod: {
+        type: "enum";
+        options: ContributionPeriod[];
     };
-    readonly deliveryOptIn: {
-        readonly type: "boolean";
+    deliveryOptIn: {
+        type: "boolean";
     };
-    readonly newsletterStatus: {
-        readonly type: "enum";
-        readonly options: readonly [NewsletterStatus.Subscribed, NewsletterStatus.Unsubscribed, NewsletterStatus.Cleaned, NewsletterStatus.None];
+    newsletterStatus: {
+        type: "enum";
+        options: NewsletterStatus[];
     };
-    readonly activePermission: {
-        readonly type: "enum";
-        readonly options: readonly ["member", "admin", "superadmin"];
+    activePermission: {
+        type: "enum";
+        options: readonly ["member", "admin", "superadmin"];
     };
-    readonly activeMembership: {
-        readonly type: "boolean";
+    activeMembership: {
+        type: "boolean";
     };
-    readonly membershipStarts: {
-        readonly type: "date";
+    membershipStarts: {
+        type: "date";
     };
-    readonly membershipExpires: {
-        readonly type: "date";
+    membershipExpires: {
+        type: "date";
     };
-    readonly manualPaymentSource: {
-        readonly type: "text";
-        readonly nullable: true;
+    manualPaymentSource: {
+        type: "text";
+        nullable: true;
     };
-    readonly tags: {
-        readonly type: "array";
-        readonly nullable: true;
+    tags: {
+        type: "array";
+        nullable: true;
     };
 };
-export declare type ContactFilterName = keyof typeof contactFilters;
+export type ContactFilterName = keyof typeof contactFilters;

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

@@ -1,6 +1,6 @@
 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 type RuleOperator = (typeof ruleOperators)[number];
+export type RuleValue = string | number | boolean;
 export interface Rule {
     field: string;
     operator: RuleOperator;
@@ -10,22 +10,23 @@ export interface RuleGroup {
     condition: "AND" | "OR";
     rules: (RuleGroup | Rule)[];
 }
-export declare type ValidatedRuleValue<T extends FilterType> = T extends "number" ? number : T extends "boolean" ? boolean : string;
+export type ValidatedRuleValue<T extends FilterType> = T extends "number" ? number : T extends "boolean" ? boolean : string;
 interface BaseValidatedRule<T extends FilterType, F extends string> {
     type: T;
     field: F;
-    operator: keyof typeof operatorsByType[T];
+    param: string | undefined;
+    operator: keyof (typeof operatorsByType)[T];
     value: ValidatedRuleValue<T>[];
 }
-declare type ValidatedNumberRule<Field extends string> = BaseValidatedRule<"number", Field>;
-declare type ValidatedStringRule<Field extends string> = BaseValidatedRule<Exclude<FilterType, "number" | "boolean">, Field>;
-declare type ValidatedBooleanRule<Field extends string> = BaseValidatedRule<"boolean", Field>;
-export declare type ValidatedRule<Field extends string> = ValidatedNumberRule<Field> | ValidatedStringRule<Field> | ValidatedBooleanRule<Field>;
+type ValidatedNumberRule<Field extends string> = BaseValidatedRule<"number", Field>;
+type ValidatedStringRule<Field extends string> = BaseValidatedRule<Exclude<FilterType, "number" | "boolean">, Field>;
+type ValidatedBooleanRule<Field extends string> = BaseValidatedRule<"boolean", Field>;
+export 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 type FilterType = "text" | "date" | "number" | "boolean" | "array" | "enum" | "contact" | "custom";
 interface BaseFilterArgs {
     type: FilterType;
     nullable?: boolean;
@@ -37,8 +38,8 @@ export interface EnumFilterArgs<T extends readonly string[] = readonly string[]>
 export interface OtherFilterArgs extends BaseFilterArgs {
     type: Exclude<FilterType, "enum">;
 }
-export declare type FilterArgs = EnumFilterArgs | OtherFilterArgs;
-export declare type Filters<T extends string = string> = Record<T, FilterArgs>;
+export type FilterArgs = EnumFilterArgs | OtherFilterArgs;
+export type Filters<T extends string = string> = Record<T, FilterArgs>;
 export interface RuleOperatorParams {
     args: number;
 }
@@ -50,34 +51,35 @@ export declare const nullableOperators: {
         args: number;
     };
 };
+type OperatorsByType = Record<FilterType, Partial<Record<RuleOperator, RuleOperatorParams>>>;
 export declare const operatorsByType: {
-    readonly text: {
-        readonly begins_with: {
-            readonly args: 1;
+    text: {
+        begins_with: {
+            args: number;
         };
-        readonly ends_with: {
-            readonly args: 1;
+        ends_with: {
+            args: number;
         };
-        readonly not_begins_with: {
-            readonly args: 1;
+        not_begins_with: {
+            args: number;
         };
-        readonly not_ends_with: {
-            readonly args: 1;
+        not_ends_with: {
+            args: number;
         };
-        readonly contains: {
+        contains: {
             args: number;
         };
-        readonly not_contains: {
+        not_contains: {
             args: number;
         };
-        readonly equal: {
+        equal: {
             args: number;
         };
-        readonly not_equal: {
+        not_equal: {
             args: number;
         };
     };
-    readonly date: {
+    date: {
         between: {
             args: number;
         };
@@ -103,7 +105,7 @@ export declare const operatorsByType: {
             args: number;
         };
     };
-    readonly number: {
+    number: {
         between: {
             args: number;
         };
@@ -129,12 +131,12 @@ export declare const operatorsByType: {
             args: number;
         };
     };
-    readonly boolean: {
-        readonly equal: {
+    boolean: {
+        equal: {
             args: number;
         };
     };
-    readonly array: {
+    array: {
         contains: {
             args: number;
         };
@@ -142,7 +144,15 @@ export declare const operatorsByType: {
             args: number;
         };
     };
-    readonly enum: {
+    enum: {
+        equal: {
+            args: number;
+        };
+        not_equal: {
+            args: number;
+        };
+    };
+    contact: {
         equal: {
             args: number;
         };
@@ -150,16 +160,52 @@ export declare const operatorsByType: {
             args: number;
         };
     };
-    readonly contact: {
+    custom: {
+        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;
         };
+        begins_with: {
+            args: number;
+        };
+        ends_with: {
+            args: number;
+        };
+        not_begins_with: {
+            args: number;
+        };
+        not_ends_with: {
+            args: number;
+        };
+        contains: {
+            args: number;
+        };
+        not_contains: {
+            args: number;
+        };
     };
 };
-export declare const operatorsByTypeMap: Record<FilterType, Partial<Record<RuleOperator, RuleOperatorParams>>>;
+export declare const operatorsByTypeMap: OperatorsByType;
 export interface Paginated<T> {
     items: T[];
     offset: number;

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

@@ -1,27 +1,27 @@
 import { ItemStatus } from "../data";
 export declare const noticeFilters: {
-    readonly createdAt: {
-        readonly type: "date";
+    createdAt: {
+        type: "date";
     };
-    readonly updatedAt: {
-        readonly type: "date";
+    updatedAt: {
+        type: "date";
     };
-    readonly name: {
-        readonly type: "text";
+    name: {
+        type: "text";
     };
-    readonly expires: {
-        readonly type: "date";
-        readonly nullable: true;
+    expires: {
+        type: "date";
+        nullable: true;
     };
-    readonly enabled: {
-        readonly type: "boolean";
+    enabled: {
+        type: "boolean";
     };
-    readonly text: {
-        readonly type: "text";
+    text: {
+        type: "text";
     };
-    readonly status: {
-        readonly type: "enum";
-        readonly options: readonly [ItemStatus.Draft, ItemStatus.Scheduled, ItemStatus.Open, ItemStatus.Ended];
+    status: {
+        type: "enum";
+        options: ItemStatus[];
     };
 };
-export declare type NoticeFilterName = keyof typeof noticeFilters;
+export type NoticeFilterName = keyof typeof noticeFilters;

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

@@ -1,9 +1,9 @@
 export declare const paymentFilters: {
-    readonly contact: {
-        readonly type: "contact";
+    contact: {
+        type: "contact";
     };
-    readonly chargeDate: {
-        readonly type: "date";
+    chargeDate: {
+        type: "date";
     };
 };
-export declare type PaymentFilterName = keyof typeof paymentFilters;
+export type PaymentFilterName = keyof typeof paymentFilters;

package/dist/types/utils/date.d.ts

@@ -1,5 +1,5 @@
 declare const dateUnits: readonly ["s", "m", "h", "d", "M", "y"];
-declare type DateUnit = typeof dateUnits[number];
+type DateUnit = (typeof dateUnits)[number];
 export declare function parseDate(value: string, now?: Date): [Date, DateUnit];
 export declare function getMinDateUnit(units: [DateUnit, ...DateUnit[]]): DateUnit;
 export declare function getMinDateUnit(units: DateUnit[]): DateUnit | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beabee/beabee-common",
-  "version": "1.10.2",
+  "version": "1.10.4",
   "description": "",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -24,12 +24,12 @@
   },
   "homepage": "https://github.com/beabee-communityrm/beabee-common#readme",
   "devDependencies": {
-    "@tsconfig/recommended": "^1.0.1",
-    "jest": "^29.3.0",
-    "prettier": "^2.7.1",
-    "rimraf": "^3.0.2",
-    "ts-jest": "^29.0.3",
-    "typescript": "^4.8.4"
+    "@tsconfig/recommended": "^1.0.2",
+    "jest": "^29.3.1",
+    "prettier": "^2.8.3",
+    "rimraf": "^4.1.1",
+    "ts-jest": "^29.0.5",
+    "typescript": "^4.9.4"
   },
   "dependencies": {
     "date-fns": "^2.29.3"