@dyrected/core 2.10.0 → 2.10.1

package/dist/index.cjs

@@ -2300,8 +2300,10 @@ var index_exports = {};
 __export(index_exports, {
   BUILTIN_JEXL_HELPERS: () => BUILTIN_JEXL_HELPERS,
   ConfigValidationError: () => ConfigValidationError,
+  FieldConditionBuilder: () => FieldConditionBuilder,
   LIFECYCLE_EVENTS_COLLECTION: () => LIFECYCLE_EVENTS_COLLECTION,
   LIFECYCLE_EVENT_NAMES: () => LIFECYCLE_EVENT_NAMES,
+  MatchBuilder: () => MatchBuilder,
   WORKFLOW_HISTORY_COLLECTION: () => WORKFLOW_HISTORY_COLLECTION,
   abs: () => abs,
   addDays: () => addDays,
@@ -2383,6 +2385,7 @@ __export(index_exports, {
   floor: () => floor,
   formatConfigDiagnostics: () => formatConfigDiagnostics,
   formatDate: () => formatDate,
+  formatJexlValue: () => formatJexlValue,
   generateDefaultDetailSchema: () => generateDefaultDetailSchema,
   generateOpenApi: () => generateOpenApi,
   get: () => get,
@@ -2434,6 +2437,7 @@ __export(index_exports, {
   validateDeclarativeAccessExpression: () => validateDeclarativeAccessExpression,
   validateDeclarativeHookExpression: () => validateDeclarativeHookExpression,
   validatePreviewUrlExpression: () => validatePreviewUrlExpression,
+  when: () => when,
   wordCount: () => wordCount,
   workflowCapabilities: () => workflowCapabilities
 });
@@ -3276,6 +3280,11 @@ function registerJexlHelpers(jexlInstance = import_jexl.default) {
   try {
     jexlInstance.addBinaryOp("and", 20, (left, right) => Boolean(left && right));
     jexlInstance.addBinaryOp("or", 10, (left, right) => Boolean(left || right));
+    jexlInstance.addBinaryOp("in", 30, (left, right) => {
+      if (Array.isArray(right)) return right.includes(left);
+      if (typeof right === "string") return right.includes(String(left ?? ""));
+      return false;
+    });
   } catch {
   }
 }
@@ -6078,6 +6087,346 @@ function isDetailItemVisible(item, doc, user) {
   return true;
 }
 
+// src/utils/conditions.ts
+function formatJexlValue(v) {
+  if (v === null || v === void 0) return "null";
+  if (typeof v === "boolean" || typeof v === "number") return String(v);
+  if (typeof v === "string") {
+    if (v.startsWith("'") && v.endsWith("'") || v.startsWith('"') && v.endsWith('"') || v.includes("+") || v.includes("?") || v.includes("(") || v.includes(" ")) {
+      return v;
+    }
+    if (v.startsWith("/")) {
+      return `'${v}'`;
+    }
+    if (v === "null" || v === "true" || v === "false") {
+      return v;
+    }
+    if (/^[a-zA-Z_$][a-zA-Z0-9_$.]*$/.test(v)) {
+      return v;
+    }
+    return `'${v}'`;
+  }
+  return String(v);
+}
+var MatchBuilder = class {
+  branches = [];
+  /**
+   * Adds a conditional branch (`condition ? value : ...`).
+   */
+  case(condition, value) {
+    this.branches.push({ condition, value });
+    return this;
+  }
+  /**
+   * Final fallback value when no cases match.
+   */
+  otherwise(fallback = "null") {
+    if (this.branches.length === 0) return formatJexlValue(fallback);
+    let expr = formatJexlValue(fallback);
+    for (let i = this.branches.length - 1; i >= 0; i--) {
+      const b = this.branches[i];
+      expr = `${b.condition} ? ${formatJexlValue(b.value)} : ${expr}`;
+    }
+    return expr;
+  }
+};
+var FieldConditionBuilder = class {
+  constructor(field) {
+    this.field = field;
+  }
+  field;
+  /**
+   * Generates equality condition (`field == value`).
+   */
+  equals(value) {
+    return `${this.field} == ${JSON.stringify(value)}`;
+  }
+  /**
+   * Generates inequality condition (`field != value`).
+   */
+  notEquals(value) {
+    return `${this.field} != ${JSON.stringify(value)}`;
+  }
+  /**
+   * Generates set membership condition (`field in [val1, val2]`).
+   */
+  in(...values) {
+    const flat = values.flat();
+    return `${this.field} in [${flat.map((v) => JSON.stringify(v)).join(", ")}]`;
+  }
+  /**
+   * Generates inverted set membership condition (`!(field in [val1, val2])`).
+   */
+  notIn(...values) {
+    const flat = values.flat();
+    return `!(${this.field} in [${flat.map((v) => JSON.stringify(v)).join(", ")}])`;
+  }
+  /**
+   * Generates boolean true check (`field == true`).
+   */
+  isTrue() {
+    return `${this.field} == true`;
+  }
+  /**
+   * Generates boolean false check (`field != true`).
+   */
+  isFalse() {
+    return `${this.field} != true`;
+  }
+  /**
+   * Checks that the field is neither null/undefined nor an empty string.
+   */
+  notEmpty() {
+    return `${this.field} != null && ${this.field} != ''`;
+  }
+  /**
+   * Checks that the field is null, undefined, or an empty string.
+   */
+  isEmpty() {
+    return `${this.field} == null || ${this.field} == ''`;
+  }
+  /**
+   * Numerical greater than (`field > num`).
+   */
+  greaterThan(num) {
+    return `${this.field} > ${typeof num === "number" ? num : num}`;
+  }
+  /**
+   * Numerical greater than or equal (`field >= num`).
+   */
+  greaterThanOrEqual(num) {
+    return `${this.field} >= ${typeof num === "number" ? num : num}`;
+  }
+  /**
+   * Numerical less than (`field < num`).
+   */
+  lessThan(num) {
+    return `${this.field} < ${typeof num === "number" ? num : num}`;
+  }
+  /**
+   * Numerical less than or equal (`field <= num`).
+   */
+  lessThanOrEqual(num) {
+    return `${this.field} <= ${typeof num === "number" ? num : num}`;
+  }
+  /**
+   * Numerical range check (`field >= min && field <= max`).
+   */
+  between(min2, max2) {
+    return `${this.field} >= ${min2} && ${this.field} <= ${max2}`;
+  }
+  /**
+   * String prefix check using JEXL `startsWith(field, prefix)`.
+   */
+  startsWith(prefix) {
+    return `startsWith(${this.field}, ${JSON.stringify(prefix)})`;
+  }
+  /**
+   * String suffix check using JEXL `endsWith(field, suffix)`.
+   */
+  endsWith(suffix) {
+    return `endsWith(${this.field}, ${JSON.stringify(suffix)})`;
+  }
+  /**
+   * Substring or array item check using JEXL `includes(field, item)`.
+   */
+  contains(val) {
+    return `includes(${this.field}, ${JSON.stringify(val)})`;
+  }
+  /**
+   * Checks if array/string length exceeds a threshold.
+   */
+  hasLengthGreaterThan(length2) {
+    return `length(${this.field}) > ${length2}`;
+  }
+  /**
+   * Checks if array/string length is at least a threshold.
+   */
+  hasLengthAtLeast(length2) {
+    return `length(${this.field}) >= ${length2}`;
+  }
+};
+function createWhen() {
+  const whenFn = ((fieldName) => new FieldConditionBuilder(fieldName));
+  whenFn.user = (userProp) => new FieldConditionBuilder(`user.${userProp}`);
+  whenFn.sibling = (siblingProp) => new FieldConditionBuilder(`siblingData.${siblingProp}`);
+  whenFn.concat = (...parts) => {
+    if (parts.length === 0) return "''";
+    return parts.map((p) => formatJexlValue(p)).join(" + ");
+  };
+  whenFn.slugify = (field) => `slugify(${field})`;
+  whenFn.lower = (field) => `lower(${field})`;
+  whenFn.upper = (field) => `upper(${field})`;
+  whenFn.trim = (field) => `trim(${field})`;
+  whenFn.access = {
+    isOwner: (ownerField = "author") => {
+      return `${ownerField} == user.id || ${ownerField}.id == user.id`;
+    },
+    isAdmin: () => {
+      return "user.role == 'admin' || (user.roles != null && 'admin' in user.roles)";
+    },
+    hasRole: (...roles) => {
+      return whenFn.userRole(...roles);
+    },
+    isPublishedOrAdmin: (statusField = "status") => {
+      return `${statusField} == 'published' || user.role == 'admin' || (user.roles != null && 'admin' in user.roles)`;
+    }
+  };
+  whenFn.then = (condition, ifTrue, ifFalse = "null") => {
+    return `${condition} ? ${formatJexlValue(ifTrue)} : ${formatJexlValue(ifFalse)}`;
+  };
+  whenFn.match = () => new MatchBuilder();
+  whenFn.cases = (...branches) => {
+    const builder = new MatchBuilder();
+    let fallback = "null";
+    for (const b of branches) {
+      if (Array.isArray(b)) {
+        builder.case(b[0], b[1]);
+      } else {
+        fallback = b;
+      }
+    }
+    return builder.otherwise(fallback);
+  };
+  whenFn.all = (...conditions) => {
+    const valid = conditions.filter(Boolean);
+    if (valid.length === 0) return "true";
+    if (valid.length === 1) return valid[0];
+    return valid.map((c) => c.includes(" ") ? `(${c})` : c).join(" && ");
+  };
+  whenFn.and = whenFn.all;
+  whenFn.any = (...conditions) => {
+    const valid = conditions.filter(Boolean);
+    if (valid.length === 0) return "true";
+    if (valid.length === 1) return valid[0];
+    return valid.map((c) => c.includes(" ") ? `(${c})` : c).join(" || ");
+  };
+  whenFn.or = whenFn.any;
+  whenFn.not = (condition) => {
+    if (!condition) return "false";
+    return `!(${condition})`;
+  };
+  whenFn.variant = (...variants) => {
+    const flat = variants.flat();
+    if (flat.length === 0) return "true";
+    if (flat.length === 1) return `variant == '${flat[0]}'`;
+    return `variant in [${flat.map((v) => `'${v}'`).join(", ")}]`;
+  };
+  whenFn.notVariant = (...variants) => {
+    const flat = variants.flat();
+    if (flat.length === 0) return "false";
+    if (flat.length === 1) return `variant != '${flat[0]}'`;
+    return `!(variant in [${flat.map((v) => `'${v}'`).join(", ")}])`;
+  };
+  whenFn.block = (...blocks) => {
+    const flat = blocks.flat();
+    if (flat.length === 0) return "true";
+    if (flat.length === 1) return `block == '${flat[0]}'`;
+    return `block in [${flat.map((b) => `'${b}'`).join(", ")}]`;
+  };
+  whenFn.notBlock = (...blocks) => {
+    const flat = blocks.flat();
+    if (flat.length === 0) return "false";
+    if (flat.length === 1) return `block != '${flat[0]}'`;
+    return `!(block in [${flat.map((b) => `'${b}'`).join(", ")}])`;
+  };
+  whenFn.fieldEquals = (field, value) => {
+    return `${field} == ${JSON.stringify(value)}`;
+  };
+  whenFn.fieldNotEquals = (field, value) => {
+    return `${field} != ${JSON.stringify(value)}`;
+  };
+  whenFn.fieldIn = (field, ...values) => {
+    const flat = values.flat();
+    return `${field} in [${flat.map((v) => JSON.stringify(v)).join(", ")}]`;
+  };
+  whenFn.fieldNotIn = (field, ...values) => {
+    const flat = values.flat();
+    return `!(${field} in [${flat.map((v) => JSON.stringify(v)).join(", ")}])`;
+  };
+  whenFn.fieldNotEmpty = (field) => {
+    return `${field} != null && ${field} != ''`;
+  };
+  whenFn.fieldEmpty = (field) => {
+    return `${field} == null || ${field} == ''`;
+  };
+  whenFn.fieldIsTrue = (field) => {
+    return `${field} == true`;
+  };
+  whenFn.fieldIsFalse = (field) => {
+    return `${field} != true`;
+  };
+  whenFn.fieldGreaterThan = (field, value) => {
+    return `${field} > ${value}`;
+  };
+  whenFn.fieldGreaterThanOrEqual = (field, value) => {
+    return `${field} >= ${value}`;
+  };
+  whenFn.fieldLessThan = (field, value) => {
+    return `${field} < ${value}`;
+  };
+  whenFn.fieldLessThanOrEqual = (field, value) => {
+    return `${field} <= ${value}`;
+  };
+  whenFn.fieldBetween = (field, min2, max2) => {
+    return `${field} >= ${min2} && ${field} <= ${max2}`;
+  };
+  whenFn.fieldStartsWith = (field, prefix) => {
+    return `startsWith(${field}, ${JSON.stringify(prefix)})`;
+  };
+  whenFn.fieldEndsWith = (field, suffix) => {
+    return `endsWith(${field}, ${JSON.stringify(suffix)})`;
+  };
+  whenFn.fieldContains = (field, item) => {
+    return `includes(${field}, ${JSON.stringify(item)})`;
+  };
+  whenFn.arrayNotEmpty = (field) => {
+    return `length(${field}) > 0`;
+  };
+  whenFn.arrayEmpty = (field) => {
+    return `length(${field}) == 0`;
+  };
+  whenFn.arrayCountGreaterThan = (field, count2) => {
+    return `length(${field}) > ${count2}`;
+  };
+  whenFn.arrayCountAtLeast = (field, count2) => {
+    return `length(${field}) >= ${count2}`;
+  };
+  whenFn.arrayCountLessThan = (field, count2) => {
+    return `length(${field}) < ${count2}`;
+  };
+  whenFn.userRole = (...roles) => {
+    const flat = roles.flat();
+    if (flat.length === 1) {
+      return `user.role == '${flat[0]}' || (user.roles != null && '${flat[0]}' in user.roles)`;
+    }
+    const roleArray = `[${flat.map((r) => `'${r}'`).join(", ")}]`;
+    return `user.role in ${roleArray} || (user.roles != null && includes(${roleArray}, user.role))`;
+  };
+  whenFn.userEmailDomain = (domain) => {
+    const clean = domain.startsWith("@") ? domain : `@${domain}`;
+    return `endsWith(user.email, '${clean}')`;
+  };
+  whenFn.userAttributeEquals = (attr, value) => {
+    return `user.${attr} == ${JSON.stringify(value)}`;
+  };
+  whenFn.isNewDocument = () => {
+    return "id == null";
+  };
+  whenFn.isExistingDocument = () => {
+    return "id != null";
+  };
+  whenFn.statusEquals = (status) => {
+    return `status == '${status}'`;
+  };
+  whenFn.statusIn = (...statuses) => {
+    const flat = statuses.flat();
+    return `status in [${flat.map((s) => `'${s}'`).join(", ")}]`;
+  };
+  return whenFn;
+}
+var when = createWhen();
+
 // src/index.ts
 function defineCollection(config) {
   return config;
@@ -6129,8 +6478,10 @@ function defineTab(args) {
 0 && (module.exports = {
   BUILTIN_JEXL_HELPERS,
   ConfigValidationError,
+  FieldConditionBuilder,
   LIFECYCLE_EVENTS_COLLECTION,
   LIFECYCLE_EVENT_NAMES,
+  MatchBuilder,
   WORKFLOW_HISTORY_COLLECTION,
   abs,
   addDays,
@@ -6212,6 +6563,7 @@ function defineTab(args) {
   floor,
   formatConfigDiagnostics,
   formatDate,
+  formatJexlValue,
   generateDefaultDetailSchema,
   generateOpenApi,
   get,
@@ -6263,6 +6615,7 @@ function defineTab(args) {
   validateDeclarativeAccessExpression,
   validateDeclarativeHookExpression,
   validatePreviewUrlExpression,
+  when,
   wordCount,
   workflowCapabilities
 });