@beabee/beabee-common 1.19.7 → 1.19.8

package/dist/cjs/utils/rules.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRuleGroup = exports.validateRule = exports.isRuleGroup = void 0;
+const error_1 = require("../error");
+const search_1 = require("../search");
+const date_1 = require("./date");
+function isRuleGroup(ruleOrGroup) {
+    return "condition" in ruleOrGroup;
+}
+exports.isRuleGroup = isRuleGroup;
+function validateRule(filters, rule) {
+    const filter = filters[rule.field];
+    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`);
+        }
+    }
+    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}`);
+        }
+        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
+        : "string";
+    if (rule.value.some((v) => typeof v !== expectedType)) {
+        throw new error_1.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, date_1.isValidDate)(v))) {
+        throw new error_1.InvalidRule(rule, `Invalid operator argument: date type needs valid absolute or relative date, ${rule.value} given`);
+    }
+    if ((filter.type === "enum" || filter.type === "array") &&
+        rule.value.some((v) => filter.options?.indexOf(v) === -1)) {
+        throw new error_1.InvalidRule(rule, `Invalid operator argument: ${filter.type} type expected ${filter.options}, ${rule.value} given`);
+    }
+    return {
+        field: rule.field,
+        type: filter.type,
+        nullable: !!filter.nullable,
+        operator: rule.operator,
+        value: rule.value,
+    };
+}
+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)
+            : validateRule(filters, rule);
+        validatedRuleGroup.rules.push(valid);
+    }
+    return validatedRuleGroup;
+}
+exports.validateRuleGroup = validateRuleGroup;

package/dist/esm/data/callouts.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/data/index.js

@@ -1,57 +1,50 @@
-var ContributionPeriod = /* @__PURE__ */ ((ContributionPeriod2) => {
-  ContributionPeriod2["Monthly"] = "monthly";
-  ContributionPeriod2["Annually"] = "annually";
-  return ContributionPeriod2;
-})(ContributionPeriod || {});
-var ContributionType = /* @__PURE__ */ ((ContributionType2) => {
-  ContributionType2["Automatic"] = "Automatic";
-  ContributionType2["Manual"] = "Manual";
-  ContributionType2["Gift"] = "Gift";
-  ContributionType2["None"] = "None";
-  return ContributionType2;
-})(ContributionType || {});
-var ItemStatus = /* @__PURE__ */ ((ItemStatus2) => {
-  ItemStatus2["Draft"] = "draft";
-  ItemStatus2["Scheduled"] = "scheduled";
-  ItemStatus2["Open"] = "open";
-  ItemStatus2["Ended"] = "ended";
-  return ItemStatus2;
-})(ItemStatus || {});
-var MembershipStatus = /* @__PURE__ */ ((MembershipStatus2) => {
-  MembershipStatus2["Active"] = "active";
-  MembershipStatus2["Expiring"] = "expiring";
-  MembershipStatus2["Expired"] = "expired";
-  MembershipStatus2["None"] = "none";
-  return MembershipStatus2;
-})(MembershipStatus || {});
-var NewsletterStatus = /* @__PURE__ */ ((NewsletterStatus2) => {
-  NewsletterStatus2["Subscribed"] = "subscribed";
-  NewsletterStatus2["Unsubscribed"] = "unsubscribed";
-  NewsletterStatus2["Cleaned"] = "cleaned";
-  NewsletterStatus2["Pending"] = "pending";
-  NewsletterStatus2["None"] = "none";
-  return NewsletterStatus2;
-})(NewsletterStatus || {});
-var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
-  PaymentMethod2["StripeCard"] = "s_card";
-  PaymentMethod2["StripeSEPA"] = "s_sepa";
-  PaymentMethod2["StripeBACS"] = "s_bacs";
-  PaymentMethod2["GoCardlessDirectDebit"] = "gc_direct-debit";
-  return PaymentMethod2;
-})(PaymentMethod || {});
-var PaymentStatus = /* @__PURE__ */ ((PaymentStatus2) => {
-  PaymentStatus2["Pending"] = "pending";
-  PaymentStatus2["Successful"] = "successful";
-  PaymentStatus2["Failed"] = "failed";
-  PaymentStatus2["Cancelled"] = "cancelled";
-  return PaymentStatus2;
-})(PaymentStatus || {});
-export {
-  ContributionPeriod,
-  ContributionType,
-  ItemStatus,
-  MembershipStatus,
-  NewsletterStatus,
-  PaymentMethod,
-  PaymentStatus
-};
+export var ContributionPeriod;
+(function (ContributionPeriod) {
+    ContributionPeriod["Monthly"] = "monthly";
+    ContributionPeriod["Annually"] = "annually";
+})(ContributionPeriod || (ContributionPeriod = {}));
+export var ContributionType;
+(function (ContributionType) {
+    ContributionType["Automatic"] = "Automatic";
+    ContributionType["Manual"] = "Manual";
+    ContributionType["Gift"] = "Gift";
+    ContributionType["None"] = "None";
+})(ContributionType || (ContributionType = {}));
+export var ItemStatus;
+(function (ItemStatus) {
+    ItemStatus["Draft"] = "draft";
+    ItemStatus["Scheduled"] = "scheduled";
+    ItemStatus["Open"] = "open";
+    ItemStatus["Ended"] = "ended";
+})(ItemStatus || (ItemStatus = {}));
+export var MembershipStatus;
+(function (MembershipStatus) {
+    MembershipStatus["Active"] = "active";
+    MembershipStatus["Expiring"] = "expiring";
+    MembershipStatus["Expired"] = "expired";
+    MembershipStatus["None"] = "none";
+})(MembershipStatus || (MembershipStatus = {}));
+export var NewsletterStatus;
+(function (NewsletterStatus) {
+    NewsletterStatus["Subscribed"] = "subscribed";
+    NewsletterStatus["Unsubscribed"] = "unsubscribed";
+    NewsletterStatus["Cleaned"] = "cleaned";
+    NewsletterStatus["Pending"] = "pending";
+    NewsletterStatus["None"] = "none";
+})(NewsletterStatus || (NewsletterStatus = {}));
+export var PaymentMethod;
+(function (PaymentMethod) {
+    PaymentMethod["StripeCard"] = "s_card";
+    PaymentMethod["StripeSEPA"] = "s_sepa";
+    PaymentMethod["StripeBACS"] = "s_bacs";
+    PaymentMethod["GoCardlessDirectDebit"] = "gc_direct-debit";
+})(PaymentMethod || (PaymentMethod = {}));
+export var PaymentStatus;
+(function (PaymentStatus) {
+    PaymentStatus["Pending"] = "pending";
+    PaymentStatus["Successful"] = "successful";
+    PaymentStatus["Failed"] = "failed";
+    PaymentStatus["Cancelled"] = "cancelled";
+})(PaymentStatus || (PaymentStatus = {}));
+export const RoleTypes = ["member", "admin", "superadmin"];
+export * from "./callouts";

package/dist/esm/error/InvalidRule.js

@@ -1,11 +1,8 @@
-class InvalidRule extends Error {
-  constructor(rule, message) {
-    super();
-    this.rule = rule;
-    this.message = message;
-    Object.setPrototypeOf(this, InvalidRule.prototype);
-  }
+export default class InvalidRule extends Error {
+    constructor(rule, message) {
+        super();
+        this.rule = rule;
+        this.message = message;
+        Object.setPrototypeOf(this, InvalidRule.prototype);
+    }
 }
-export {
-  InvalidRule
-};

package/dist/esm/error/index.js

@@ -1 +1,2 @@
-export * from "./InvalidRule.js";
+import InvalidRule from "./InvalidRule";
+export { InvalidRule };

package/dist/esm/index.js

@@ -1,4 +1,7 @@
-export * from "./data/index.js";
-export * from "./error/index.js";
-export * from "./search/index.js";
-export * from "./utils/index.js";
+export * from "./search";
+export * from "./data";
+export * from "./error";
+export * from "./utils/callouts";
+export * from "./utils/date";
+export * from "./utils/payments";
+export * from "./utils/rules";

package/dist/esm/search/api-keys.js

@@ -1,11 +1,8 @@
-const apiKeyFilters = {
-  id: {
-    type: "text"
-  },
-  createdAt: {
-    type: "date"
-  }
-};
-export {
-  apiKeyFilters
+export const apiKeyFilters = {
+    id: {
+        type: "text",
+    },
+    createdAt: {
+        type: "date",
+    },
 };

package/dist/esm/search/callouts.js

@@ -1,104 +1,98 @@
-import { ItemStatus } from "../data/index.js";
-const calloutFilters = {
-  slug: {
-    type: "text"
-  },
-  title: {
-    type: "text"
-  },
-  status: {
-    type: "enum",
-    options: [
-      ItemStatus.Draft,
-      ItemStatus.Scheduled,
-      ItemStatus.Open,
-      ItemStatus.Ended
-    ]
-  },
-  answeredBy: {
-    type: "contact"
-  },
-  starts: {
-    type: "date",
-    nullable: true
-  },
-  expires: {
-    type: "date",
-    nullable: true
-  },
-  hidden: {
-    type: "boolean"
-  }
+import { ItemStatus } from "../data";
+export const calloutFilters = {
+    slug: {
+        type: "text",
+    },
+    title: {
+        type: "text",
+    },
+    status: {
+        type: "enum",
+        options: [
+            ItemStatus.Draft,
+            ItemStatus.Scheduled,
+            ItemStatus.Open,
+            ItemStatus.Ended,
+        ],
+    },
+    answeredBy: {
+        type: "contact",
+    },
+    starts: {
+        type: "date",
+        nullable: true,
+    },
+    expires: {
+        type: "date",
+        nullable: true,
+    },
+    hidden: {
+        type: "boolean",
+    },
 };
-const calloutResponseFilters = {
-  id: {
-    type: "text"
-  },
-  contact: {
-    type: "contact",
-    nullable: true
-  },
-  callout: {
-    type: "text"
-  },
-  createdAt: {
-    type: "date"
-  },
-  updatedAt: {
-    type: "date"
-  },
-  bucket: {
-    type: "text",
-    nullable: true
-  },
-  tags: {
-    type: "array"
-  },
-  assignee: {
-    type: "contact",
-    nullable: true
-  },
-  answers: {
-    type: "blob"
-  }
+export const calloutResponseFilters = {
+    id: {
+        type: "text",
+    },
+    contact: {
+        type: "contact",
+        nullable: true,
+    },
+    callout: {
+        type: "text",
+    },
+    createdAt: {
+        type: "date",
+    },
+    updatedAt: {
+        type: "date",
+    },
+    bucket: {
+        type: "text",
+        nullable: true,
+    },
+    tags: {
+        type: "array",
+    },
+    assignee: {
+        type: "contact",
+        nullable: true,
+    },
+    answers: {
+        type: "blob",
+    },
 };
-const calloutResponseCommentFilters = {
-  id: {
-    type: "text"
-  },
-  responseId: {
-    type: "text"
-  },
-  contact: {
-    type: "contact"
-  },
-  createdAt: {
-    type: "date"
-  },
-  updatedAt: {
-    type: "date"
-  },
-  text: {
-    type: "text"
-  }
+export const calloutResponseCommentFilters = {
+    id: {
+        type: "text",
+    },
+    responseId: {
+        type: "text",
+    },
+    contact: {
+        type: "contact",
+    },
+    createdAt: {
+        type: "date",
+    },
+    updatedAt: {
+        type: "date",
+    },
+    text: {
+        type: "text",
+    },
 };
-const calloutTagFilters = {
-  id: {
-    type: "text"
-  },
-  name: {
-    type: "text"
-  },
-  description: {
-    type: "text"
-  },
-  calloutSlug: {
-    type: "text"
-  }
-};
-export {
-  calloutFilters,
-  calloutResponseCommentFilters,
-  calloutResponseFilters,
-  calloutTagFilters
+export const calloutTagFilters = {
+    id: {
+        type: "text",
+    },
+    name: {
+        type: "text",
+    },
+    description: {
+        type: "text",
+    },
+    calloutSlug: {
+        type: "text",
+    },
 };

package/dist/esm/search/contacts.js

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

package/dist/esm/search/index.js

@@ -1,6 +1,64 @@
-export * from "./api-keys.js";
-export * from "./callouts.js";
-export * from "./contacts.js";
-export * from "./notices.js";
-export * from "./operators.js";
-export * from "./payments.js";
+// *** Definitions for rules ***
+export const ruleOperators = [
+    "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",
+];
+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 },
+    not_between: { args: 2 },
+    less: { args: 1 },
+    greater: { args: 1 },
+    less_or_equal: { args: 1 },
+    greater_or_equal: { args: 1 },
+};
+const arrayOperators = {
+    contains: { args: 1 },
+    not_contains: { args: 1 },
+};
+// Special operator can be applied across all fields if they are nullable
+export const nullableOperators = {
+    is_empty: { args: 0 },
+    is_not_empty: { args: 0 },
+};
+export const operatorsByType = {
+    text: { ...equalityOperators, ...arrayOperators, ...stringOperators },
+    blob: arrayOperators,
+    date: numericOperators,
+    number: numericOperators,
+    boolean: { equal: equalityOperators.equal },
+    array: arrayOperators,
+    enum: equalityOperators,
+    contact: equalityOperators,
+};
+// More general type to allow mapping while maintaining full type above
+export const operatorsByTypeMap = operatorsByType;
+export * from "./api-keys";
+export * from "./callouts";
+export * from "./contacts";
+export * from "./notices";
+export * from "./payments";