@dyrected/core 2.9.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
 });
@@ -2449,37 +2453,10 @@ var LIFECYCLE_EVENT_NAMES = [
 
 // src/types/views.ts
 function defineView(config) {
-  return {
-    slug: config.slug,
-    label: config.label,
-    icon: config.icon,
-    layout: config.layout ?? "table",
-    filter: config.filter,
-    groupBy: config.groupBy,
-    dateField: config.dateField,
-    startDateField: config.startDateField,
-    endDateField: config.endDateField,
-    columns: config.columns,
-    sort: config.sort,
-    actions: config.actions,
-    features: config.features,
-    actionOrder: config.actionOrder,
-    metrics: config.metrics,
-    access: config.access
-  };
+  return config;
 }
 function defineAction(config) {
-  return {
-    name: config.name,
-    label: config.label,
-    icon: config.icon,
-    type: config.type ?? "row",
-    confirm: config.confirm,
-    fields: config.fields,
-    mutation: config.mutation,
-    handler: config.handler,
-    access: config.access
-  };
+  return config;
 }
 
 // src/auth/token.ts
@@ -3303,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 {
   }
 }
@@ -4298,7 +4280,7 @@ function normalizeConfig(config) {
 function assertNever(op, context) {
   throw new Error(`[dyrected/core] Unhandled where operator "${op}" in ${context}`);
 }
-function parseSqlWhere(where, getJsonField, placeholder = "?", likeOperator = "LIKE") {
+function parseSqlWhere(where, getJsonField, placeholder = "?", likeOperator = placeholder === "pg" ? "ILIKE" : "LIKE") {
   const params = [];
   let pgIndex = 1;
   function next() {
@@ -4309,8 +4291,16 @@ function parseSqlWhere(where, getJsonField, placeholder = "?", likeOperator = "L
   }
   function buildOperator(field, value) {
     const c = col(field);
+    const isJsonExtract = c.startsWith("data->>") || c.startsWith("json_extract(") || c.startsWith("JSON_UNQUOTE(");
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
-      params.push(typeof value === "boolean" ? String(value) : value);
+      if (value === null) {
+        return `${c} IS NULL`;
+      }
+      if (value === "" && placeholder === "pg") {
+        params.push("");
+        return `(${c})::text = ${next()}`;
+      }
+      params.push(typeof value === "boolean" && isJsonExtract ? String(value) : value);
       return `${c} = ${next()}`;
     }
     const entries = Object.entries(value);
@@ -4321,18 +4311,63 @@ function parseSqlWhere(where, getJsonField, placeholder = "?", likeOperator = "L
     return buildSingleOp(c, op, operand);
   }
   function buildSingleOp(c, op, operand) {
+    const isJsonExtract = c.startsWith("data->>") || c.startsWith("json_extract(") || c.startsWith("JSON_UNQUOTE(");
     switch (op) {
       case "equals":
-        params.push(typeof operand === "boolean" ? String(operand) : operand);
+        if (operand === null) {
+          return `${c} IS NULL`;
+        }
+        if (operand === "" && placeholder === "pg") {
+          params.push("");
+          return `(${c})::text = ${next()}`;
+        }
+        if (typeof operand === "boolean") {
+          if (placeholder === "?") {
+            params.push(operand ? 1 : 0);
+          } else if (isJsonExtract) {
+            params.push(String(operand));
+          } else {
+            params.push(operand);
+          }
+        } else {
+          params.push(operand);
+        }
         return `${c} = ${next()}`;
       case "not_equals":
-        params.push(typeof operand === "boolean" ? String(operand) : operand);
+        if (operand === null) {
+          return `${c} IS NOT NULL`;
+        }
+        if (operand === "" && placeholder === "pg") {
+          params.push("");
+          return `(${c})::text != ${next()}`;
+        }
+        if (typeof operand === "boolean") {
+          if (placeholder === "?") {
+            params.push(operand ? 1 : 0);
+          } else if (isJsonExtract) {
+            params.push(String(operand));
+          } else {
+            params.push(operand);
+          }
+        } else {
+          params.push(operand);
+        }
         return `${c} != ${next()}`;
       case "in": {
         const vals = Array.isArray(operand) ? operand : [operand];
         if (vals.length === 0) return "1=0";
         const placeholders = vals.map((v) => {
-          params.push(typeof v === "boolean" ? String(v) : v);
+          if (typeof v === "boolean") {
+            if (placeholder === "?") {
+              params.push(v ? 1 : 0);
+            } else if (isJsonExtract) {
+              params.push(String(v));
+            } else {
+              params.push(v);
+            }
+          } else {
+            params.push(v);
+          }
           return next();
         });
         return `${c} IN (${placeholders.join(", ")})`;
@@ -4341,7 +4376,7 @@ function parseSqlWhere(where, getJsonField, placeholder = "?", likeOperator = "L
         const vals = Array.isArray(operand) ? operand : [operand];
         if (vals.length === 0) return "1=1";
         const placeholders = vals.map((v) => {
-          params.push(typeof v === "boolean" ? String(v) : v);
+          params.push(typeof v === "boolean" && isJsonExtract ? String(v) : v);
           return next();
         });
         return `${c} NOT IN (${placeholders.join(", ")})`;
@@ -4367,10 +4402,10 @@ function parseSqlWhere(where, getJsonField, placeholder = "?", likeOperator = "L
       case "contains":
       case "like":
         params.push(`%${operand}%`);
-        return `${c} ${likeOperator} ${next()}`;
+        return placeholder === "pg" ? `(${c})::text ${likeOperator} ${next()}` : `${c} ${likeOperator} ${next()}`;
       case "starts_with":
         params.push(`${operand}%`);
-        return `${c} ${likeOperator} ${next()}`;
+        return placeholder === "pg" ? `(${c})::text ${likeOperator} ${next()}` : `${c} ${likeOperator} ${next()}`;
       case "exists":
         return operand ? `${c} IS NOT NULL` : `${c} IS NULL`;
       default:
@@ -5151,39 +5186,94 @@ function generateOpenApi(config) {
       post: {
         tags: [collectionTag],
         summary: `Aggregate ${labels.plural}`,
-        description: `Compute statistical aggregations (count, sum, avg, min, max) across ${labels.plural}.`,
+        description: `Compute statistical aggregations (count, countDistinct, distinct, sum, avg, min, max, groupBy) across ${labels.plural}.`,
+        parameters: [
+          {
+            name: "groupBy",
+            in: "query",
+            description: "Optional field name to compute aggregates grouped by distinct values",
+            required: false,
+            schema: { type: "string" }
+          }
+        ],
         requestBody: {
           required: true,
           content: {
             "application/json": {
               schema: {
-                type: "object",
-                additionalProperties: {
-                  type: "object",
-                  properties: {
-                    count: { type: "string", example: "*" },
-                    sum: { type: "string", description: "Field to sum" },
-                    avg: { type: "string", description: "Field to average" },
-                    min: { type: "string", description: "Field for minimum" },
-                    max: { type: "string", description: "Field for maximum" },
-                    cast: {
-                      type: "string",
-                      enum: [
-                        "number",
-                        "integer",
-                        "float",
-                        "boolean",
-                        "date",
-                        "string"
-                      ]
-                    },
-                    where: {
+                oneOf: [
+                  {
+                    type: "object",
+                    description: "Flat aggregate operations dictionary",
+                    additionalProperties: {
                       type: "object",
-                      description: "Per-aggregate filter condition",
-                      additionalProperties: true
+                      properties: {
+                        count: { type: "string", example: "*" },
+                        countDistinct: { type: "string", description: "Field to count unique non-null values" },
+                        distinct: { type: "string", description: "Field to extract unique non-null values" },
+                        sum: { type: "string", description: "Field to sum" },
+                        avg: { type: "string", description: "Field to average" },
+                        min: { type: "string", description: "Field for minimum" },
+                        max: { type: "string", description: "Field for maximum" },
+                        cast: {
+                          type: "string",
+                          enum: [
+                            "number",
+                            "integer",
+                            "float",
+                            "boolean",
+                            "date",
+                            "string"
+                          ]
+                        },
+                        where: {
+                          type: "object",
+                          description: "Per-aggregate filter condition",
+                          additionalProperties: true
+                        }
+                      }
                     }
+                  },
+                  {
+                    type: "object",
+                    description: "Grouped aggregate payload with explicit groupBy property",
+                    properties: {
+                      groupBy: { type: "string", description: "Field name to group aggregates by" },
+                      aggregates: {
+                        type: "object",
+                        additionalProperties: {
+                          type: "object",
+                          properties: {
+                            count: { type: "string", example: "*" },
+                            countDistinct: { type: "string", description: "Field to count unique non-null values" },
+                            distinct: { type: "string", description: "Field to extract unique non-null values" },
+                            sum: { type: "string", description: "Field to sum" },
+                            avg: { type: "string", description: "Field to average" },
+                            min: { type: "string", description: "Field for minimum" },
+                            max: { type: "string", description: "Field for maximum" },
+                            cast: {
+                              type: "string",
+                              enum: [
+                                "number",
+                                "integer",
+                                "float",
+                                "boolean",
+                                "date",
+                                "string"
+                              ]
+                            },
+                            where: {
+                              type: "object",
+                              description: "Per-aggregate filter condition",
+                              additionalProperties: true
+                            }
+                          }
+                        }
+                      }
+                    },
+                    required: ["aggregates"]
                   }
-                }
+                ]
               }
             }
           }
@@ -5194,11 +5284,36 @@ function generateOpenApi(config) {
             content: {
               "application/json": {
                 schema: {
-                  type: "object",
-                  additionalProperties: {
-                    type: "number",
-                    nullable: true
-                  }
+                  oneOf: [
+                    {
+                      type: "object",
+                      description: "Flat aggregate results map",
+                      additionalProperties: {
+                        oneOf: [
+                          { type: "number", nullable: true },
+                          { type: "array", items: { type: "string" } }
+                        ]
+                      }
+                    },
+                    {
+                      type: "object",
+                      description: "Grouped aggregate results breakdown",
+                      properties: {
+                        groups: {
+                          type: "object",
+                          additionalProperties: {
+                            type: "object",
+                            additionalProperties: {
+                              oneOf: [
+                                { type: "number", nullable: true },
+                                { type: "array", items: { type: "string" } }
+                              ]
+                            }
+                          }
+                        }
+                      }
+                    }
+                  ]
                 }
               }
             }
@@ -5972,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;
@@ -6023,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,
@@ -6106,6 +6563,7 @@ function defineTab(args) {
   floor,
   formatConfigDiagnostics,
   formatDate,
+  formatJexlValue,
   generateDefaultDetailSchema,
   generateOpenApi,
   get,
@@ -6157,6 +6615,7 @@ function defineTab(args) {
   validateDeclarativeAccessExpression,
   validateDeclarativeHookExpression,
   validatePreviewUrlExpression,
+  when,
   wordCount,
   workflowCapabilities
 });