@dyrected/core 2.10.1 → 2.12.0

package/dist/index.cjs

@@ -911,7 +911,7 @@ var require_Evaluator = __commonJS({
          */
       }, {
         key: "_filterRelative",
-        value: function _filterRelative(subject, expr) {
+        value: function _filterRelative(subject, expr2) {
           var _this4 = this;
           var promises = [];
           if (!Array.isArray(subject)) {
@@ -919,7 +919,7 @@ var require_Evaluator = __commonJS({
           }
           subject.forEach(function(elem) {
             var evalInst = new Evaluator2(_this4._grammar, _this4._context, elem, _this4.Promise);
-            promises.push(evalInst.eval(expr));
+            promises.push(evalInst.eval(expr2));
           });
           return this.Promise.all(promises).then(function(values) {
             var results = [];
@@ -948,8 +948,8 @@ var require_Evaluator = __commonJS({
          */
       }, {
         key: "_filterStatic",
-        value: function _filterStatic(subject, expr) {
-          return this.eval(expr).then(function(res) {
+        value: function _filterStatic(subject, expr2) {
+          return this.eval(expr2).then(function(res) {
             if (typeof res === "boolean") {
               return res ? subject : void 0;
             }
@@ -2253,7 +2253,7 @@ var require_Jexl = __commonJS({
          */
       }, {
         key: "expr",
-        value: function expr(strs) {
+        value: function expr2(strs) {
           for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
             args[_key - 1] = arguments[_key];
           }
@@ -2381,6 +2381,7 @@ __export(index_exports, {
   evaluateJexlSync: () => evaluateJexlSync,
   executeFieldAfterRead: () => executeFieldAfterRead,
   executeFieldBeforeChange: () => executeFieldBeforeChange,
+  expr: () => expr,
   first: () => first,
   floor: () => floor,
   formatConfigDiagnostics: () => formatConfigDiagnostics,
@@ -3977,6 +3978,21 @@ var SYSTEM_FIELDS = [
     admin: { readOnly: true, hidden: true }
   }
 ];
+var MEDIA_SYSTEM_FIELDS = [
+  { name: "folderId", type: "text", label: "Folder", admin: { hidden: true } },
+  { name: "filename", type: "text", label: "Filename", required: true },
+  { name: "originalFilename", type: "text", label: "Original Filename", admin: { hidden: true } },
+  { name: "mimeType", type: "text", label: "MIME Type", admin: { hidden: true } },
+  { name: "filesize", type: "number", label: "File Size", admin: { hidden: true } },
+  { name: "url", type: "text", label: "URL", admin: { hidden: true } },
+  { name: "width", type: "number", label: "Width", admin: { hidden: true } },
+  { name: "height", type: "number", label: "Height", admin: { hidden: true } },
+  { name: "aspectRatio", type: "number", label: "Aspect Ratio", admin: { hidden: true } },
+  { name: "blurhash", type: "text", label: "Blurhash", admin: { hidden: true } },
+  { name: "focalPoint", type: "json", label: "Focal Point", admin: { hidden: true } },
+  { name: "alt", type: "text", label: "Alt Text" },
+  { name: "caption", type: "text", label: "Caption" }
+];
 var AUDIT_COLLECTION = {
   slug: AUDIT_COLLECTION_SLUG,
   labels: { singular: "Audit Log", plural: "Audit Logs" },
@@ -4248,6 +4264,11 @@ function normalizeConfig(config) {
         }
       }
     }
+    if (col.upload || col.slug === "media") {
+      const currentNames = new Set(fields.map((f) => f.name));
+      const mediaFieldsToInject = MEDIA_SYSTEM_FIELDS.filter((f) => !currentNames.has(f.name));
+      fields = [...fields, ...mediaFieldsToInject];
+    }
     const updatedFieldNames = new Set(fields.map((f) => f.name));
     const fieldsToInject = SYSTEM_FIELDS.filter((f) => !updatedFieldNames.has(f.name));
     const workflow = col.workflow || (col.drafts ? simplePublishingWorkflow() : void 0);
@@ -4540,8 +4561,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(", ");
 }
 
@@ -6122,12 +6143,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 {
@@ -6185,6 +6206,12 @@ var FieldConditionBuilder = class {
   isEmpty() {
     return `${this.field} == null || ${this.field} == ''`;
   }
+  /**
+   * Alias for `isEmpty()`.
+   */
+  empty() {
+    return this.isEmpty();
+  }
   /**
    * Numerical greater than (`field > num`).
    */
@@ -6245,20 +6272,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`;
     },
@@ -6266,17 +6317,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) {
@@ -6288,114 +6340,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)`;
@@ -6403,29 +6471,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) {
@@ -6559,6 +6628,7 @@ function defineTab(args) {
   evaluateJexlSync,
   executeFieldAfterRead,
   executeFieldBeforeChange,
+  expr,
   first,
   floor,
   formatConfigDiagnostics,