@dyrected/core 2.11.0 → 2.12.0

package/dist/index.js

@@ -101,7 +101,7 @@ import {
   validatePreviewUrlExpression,
   wordCount,
   workflowCapabilities
-} from "./chunk-H7DVVW2P.js";
+} from "./chunk-VOE2LOLF.js";
 import "./chunk-JSBRDJBE.js";
 
 // src/types/workflows.ts
@@ -384,8 +384,8 @@ function buildSqlOrderBy(sort, existingColumns, numericFields, dialect) {
       return `${dialect.quoteIdent(field)} ${direction}`;
     }
     const extracted = dialect.jsonExtract(field);
-    const expr = numericFields.has(field) ? dialect.castNumeric(extracted) : extracted;
-    return `${expr} ${direction}`;
+    const expr2 = numericFields.has(field) ? dialect.castNumeric(extracted) : extracted;
+    return `${expr2} ${direction}`;
   }).join(", ");
 }
 
@@ -424,12 +424,12 @@ var MatchBuilder = class {
    */
   otherwise(fallback = "null") {
     if (this.branches.length === 0) return formatJexlValue(fallback);
-    let expr = formatJexlValue(fallback);
+    let expr2 = formatJexlValue(fallback);
     for (let i = this.branches.length - 1; i >= 0; i--) {
       const b = this.branches[i];
-      expr = `${b.condition} ? ${formatJexlValue(b.value)} : ${expr}`;
+      expr2 = `${b.condition} ? ${formatJexlValue(b.value)} : ${expr2}`;
     }
-    return expr;
+    return expr2;
   }
 };
 var FieldConditionBuilder = class {
@@ -487,6 +487,12 @@ var FieldConditionBuilder = class {
   isEmpty() {
     return `${this.field} == null || ${this.field} == ''`;
   }
+  /**
+   * Alias for `isEmpty()`.
+   */
+  empty() {
+    return this.isEmpty();
+  }
   /**
    * Numerical greater than (`field > num`).
    */
@@ -547,20 +553,44 @@ var FieldConditionBuilder = class {
   hasLengthAtLeast(length2) {
     return `length(${this.field}) >= ${length2}`;
   }
+  /**
+   * Generates a JEXL `slugify(field)` transform expression.
+   */
+  slugify() {
+    return `slugify(${this.field})`;
+  }
+  /**
+   * Generates a JEXL `lower(field)` transform expression.
+   */
+  lower() {
+    return `lower(${this.field})`;
+  }
+  /**
+   * Generates a JEXL `upper(field)` transform expression.
+   */
+  upper() {
+    return `upper(${this.field})`;
+  }
+  /**
+   * Generates a JEXL `trim(field)` transform expression.
+   */
+  trim() {
+    return `trim(${this.field})`;
+  }
 };
-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) => {
+function createExpr() {
+  const exprFn = ((fieldName) => new FieldConditionBuilder(fieldName));
+  exprFn.user = (userProp) => new FieldConditionBuilder(`user.${userProp}`);
+  exprFn.sibling = (siblingProp) => new FieldConditionBuilder(`siblingData.${siblingProp}`);
+  exprFn.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 = {
+  exprFn.slugify = (field) => `slugify(${field})`;
+  exprFn.lower = (field) => `lower(${field})`;
+  exprFn.upper = (field) => `upper(${field})`;
+  exprFn.trim = (field) => `trim(${field})`;
+  exprFn.access = {
     isOwner: (ownerField = "author") => {
       return `${ownerField} == user.id || ${ownerField}.id == user.id`;
     },
@@ -568,17 +598,18 @@ function createWhen() {
       return "user.role == 'admin' || (user.roles != null && 'admin' in user.roles)";
     },
     hasRole: (...roles) => {
-      return whenFn.userRole(...roles);
+      return exprFn.userRole(...roles);
     },
     isPublishedOrAdmin: (statusField = "status") => {
       return `${statusField} == 'published' || user.role == 'admin' || (user.roles != null && 'admin' in user.roles)`;
     }
   };
-  whenFn.then = (condition, ifTrue, ifFalse = "null") => {
+  exprFn.ifElse = (condition, ifTrue, ifFalse = "null") => {
     return `${condition} ? ${formatJexlValue(ifTrue)} : ${formatJexlValue(ifFalse)}`;
   };
-  whenFn.match = () => new MatchBuilder();
-  whenFn.cases = (...branches) => {
+  exprFn.then = exprFn.ifElse;
+  exprFn.match = () => new MatchBuilder();
+  exprFn.cases = (...branches) => {
     const builder = new MatchBuilder();
     let fallback = "null";
     for (const b of branches) {
@@ -590,114 +621,130 @@ function createWhen() {
     }
     return builder.otherwise(fallback);
   };
-  whenFn.all = (...conditions) => {
+  exprFn.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) => {
+  exprFn.and = exprFn.all;
+  exprFn.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) => {
+  exprFn.or = exprFn.any;
+  exprFn.not = (condition) => {
     if (!condition) return "false";
     return `!(${condition})`;
   };
-  whenFn.variant = (...variants) => {
+  exprFn.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) => {
+  exprFn.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) => {
+  exprFn.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) => {
+  exprFn.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) => {
+  exprFn.equals = (field, value) => {
     return `${field} == ${JSON.stringify(value)}`;
   };
-  whenFn.fieldNotEquals = (field, value) => {
+  exprFn.fieldEquals = exprFn.equals;
+  exprFn.notEquals = (field, value) => {
     return `${field} != ${JSON.stringify(value)}`;
   };
-  whenFn.fieldIn = (field, ...values) => {
+  exprFn.fieldNotEquals = exprFn.notEquals;
+  exprFn.in = (field, ...values) => {
     const flat = values.flat();
     return `${field} in [${flat.map((v) => JSON.stringify(v)).join(", ")}]`;
   };
-  whenFn.fieldNotIn = (field, ...values) => {
+  exprFn.fieldIn = exprFn.in;
+  exprFn.notIn = (field, ...values) => {
     const flat = values.flat();
     return `!(${field} in [${flat.map((v) => JSON.stringify(v)).join(", ")}])`;
   };
-  whenFn.fieldNotEmpty = (field) => {
+  exprFn.fieldNotIn = exprFn.notIn;
+  exprFn.notEmpty = (field) => {
     return `${field} != null && ${field} != ''`;
   };
-  whenFn.fieldEmpty = (field) => {
+  exprFn.fieldNotEmpty = exprFn.notEmpty;
+  exprFn.empty = (field) => {
     return `${field} == null || ${field} == ''`;
   };
-  whenFn.fieldIsTrue = (field) => {
+  exprFn.fieldEmpty = exprFn.empty;
+  exprFn.isTrue = (field) => {
     return `${field} == true`;
   };
-  whenFn.fieldIsFalse = (field) => {
+  exprFn.fieldIsTrue = exprFn.isTrue;
+  exprFn.isFalse = (field) => {
     return `${field} != true`;
   };
-  whenFn.fieldGreaterThan = (field, value) => {
+  exprFn.fieldIsFalse = exprFn.isFalse;
+  exprFn.greaterThan = (field, value) => {
     return `${field} > ${value}`;
   };
-  whenFn.fieldGreaterThanOrEqual = (field, value) => {
+  exprFn.fieldGreaterThan = exprFn.greaterThan;
+  exprFn.greaterThanOrEqual = (field, value) => {
     return `${field} >= ${value}`;
   };
-  whenFn.fieldLessThan = (field, value) => {
+  exprFn.fieldGreaterThanOrEqual = exprFn.greaterThanOrEqual;
+  exprFn.lessThan = (field, value) => {
     return `${field} < ${value}`;
   };
-  whenFn.fieldLessThanOrEqual = (field, value) => {
+  exprFn.fieldLessThan = exprFn.lessThan;
+  exprFn.lessThanOrEqual = (field, value) => {
     return `${field} <= ${value}`;
   };
-  whenFn.fieldBetween = (field, min2, max2) => {
+  exprFn.fieldLessThanOrEqual = exprFn.lessThanOrEqual;
+  exprFn.between = (field, min2, max2) => {
     return `${field} >= ${min2} && ${field} <= ${max2}`;
   };
-  whenFn.fieldStartsWith = (field, prefix) => {
+  exprFn.fieldBetween = exprFn.between;
+  exprFn.startsWith = (field, prefix) => {
     return `startsWith(${field}, ${JSON.stringify(prefix)})`;
   };
-  whenFn.fieldEndsWith = (field, suffix) => {
+  exprFn.fieldStartsWith = exprFn.startsWith;
+  exprFn.endsWith = (field, suffix) => {
     return `endsWith(${field}, ${JSON.stringify(suffix)})`;
   };
-  whenFn.fieldContains = (field, item) => {
+  exprFn.fieldEndsWith = exprFn.endsWith;
+  exprFn.contains = (field, item) => {
     return `includes(${field}, ${JSON.stringify(item)})`;
   };
-  whenFn.arrayNotEmpty = (field) => {
+  exprFn.fieldContains = exprFn.contains;
+  exprFn.arrayNotEmpty = (field) => {
     return `length(${field}) > 0`;
   };
-  whenFn.arrayEmpty = (field) => {
+  exprFn.arrayEmpty = (field) => {
     return `length(${field}) == 0`;
   };
-  whenFn.arrayCountGreaterThan = (field, count2) => {
+  exprFn.arrayCountGreaterThan = (field, count2) => {
     return `length(${field}) > ${count2}`;
   };
-  whenFn.arrayCountAtLeast = (field, count2) => {
+  exprFn.arrayCountAtLeast = (field, count2) => {
     return `length(${field}) >= ${count2}`;
   };
-  whenFn.arrayCountLessThan = (field, count2) => {
+  exprFn.arrayCountLessThan = (field, count2) => {
     return `length(${field}) < ${count2}`;
   };
-  whenFn.userRole = (...roles) => {
+  exprFn.userRole = (...roles) => {
     const flat = roles.flat();
     if (flat.length === 1) {
       return `user.role == '${flat[0]}' || (user.roles != null && '${flat[0]}' in user.roles)`;
@@ -705,29 +752,30 @@ function createWhen() {
     const roleArray = `[${flat.map((r) => `'${r}'`).join(", ")}]`;
     return `user.role in ${roleArray} || (user.roles != null && includes(${roleArray}, user.role))`;
   };
-  whenFn.userEmailDomain = (domain) => {
+  exprFn.userEmailDomain = (domain) => {
     const clean = domain.startsWith("@") ? domain : `@${domain}`;
     return `endsWith(user.email, '${clean}')`;
   };
-  whenFn.userAttributeEquals = (attr, value) => {
+  exprFn.userAttributeEquals = (attr, value) => {
     return `user.${attr} == ${JSON.stringify(value)}`;
   };
-  whenFn.isNewDocument = () => {
+  exprFn.isNewDocument = () => {
     return "id == null";
   };
-  whenFn.isExistingDocument = () => {
+  exprFn.isExistingDocument = () => {
     return "id != null";
   };
-  whenFn.statusEquals = (status) => {
+  exprFn.statusEquals = (status) => {
     return `status == '${status}'`;
   };
-  whenFn.statusIn = (...statuses) => {
+  exprFn.statusIn = (...statuses) => {
     const flat = statuses.flat();
     return `status in [${flat.map((s) => `'${s}'`).join(", ")}]`;
   };
-  return whenFn;
+  return exprFn;
 }
-var when = createWhen();
+var expr = createExpr();
+var when = expr;
 
 // src/index.ts
 function defineCollection(config) {
@@ -860,6 +908,7 @@ export {
   evaluateJexlSync,
   executeFieldAfterRead,
   executeFieldBeforeChange,
+  expr,
   first,
   floor,
   formatConfigDiagnostics,