@dyrected/core 2.9.0 → 2.10.1

package/dist/index.js

@@ -101,7 +101,7 @@ import {
   validatePreviewUrlExpression,
   wordCount,
   workflowCapabilities
-} from "./chunk-XRIONGRY.js";
+} from "./chunk-H7DVVW2P.js";
 import "./chunk-JSBRDJBE.js";
 
 // src/types/workflows.ts
@@ -114,44 +114,17 @@ 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/utils/parse-where.ts
 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() {
@@ -162,8 +135,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);
@@ -174,18 +155,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(", ")})`;
@@ -194,7 +220,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(", ")})`;
@@ -220,10 +246,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:
@@ -363,6 +389,346 @@ function buildSqlOrderBy(sort, existingColumns, numericFields, dialect) {
   }).join(", ");
 }
 
+// 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;
@@ -413,8 +779,10 @@ function defineTab(args) {
 export {
   BUILTIN_JEXL_HELPERS,
   ConfigValidationError,
+  FieldConditionBuilder,
   LIFECYCLE_EVENTS_COLLECTION,
   LIFECYCLE_EVENT_NAMES,
+  MatchBuilder,
   WORKFLOW_HISTORY_COLLECTION,
   abs,
   addDays,
@@ -496,6 +864,7 @@ export {
   floor,
   formatConfigDiagnostics,
   formatDate,
+  formatJexlValue,
   generateDefaultDetailSchema,
   generateOpenApi,
   get,
@@ -547,6 +916,7 @@ export {
   validateDeclarativeAccessExpression,
   validateDeclarativeHookExpression,
   validatePreviewUrlExpression,
+  when,
   wordCount,
   workflowCapabilities
 };