@strapi/utils 5.13.0-beta.1 → 5.13.1

package/dist/index.d.ts

@@ -22,6 +22,7 @@ export * as errors from './errors';
 export * as contentTypes from './content-types';
 export * as relations from './relations';
 export * as hooks from './hooks';
+export * as rulesEngine from './rules-engine';
 export * from './zod';
 export * from './primitives';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE3D,OAAO,KAAK,WAAW,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,cAAc,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAC7B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,YAAY,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,cAAc,OAAO,CAAC;AAEtB,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE3D,OAAO,KAAK,WAAW,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,cAAc,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAC7B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,YAAY,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,WAAW,MAAM,gBAAgB,CAAC;AAC9C,cAAc,OAAO,CAAC;AAEtB,cAAc,cAAc,CAAC"}

package/dist/index.js

@@ -24,6 +24,7 @@ var errors = require('./errors.js');
 var contentTypes = require('./content-types.js');
 var relations = require('./relations.js');
 var hooks = require('./hooks.js');
+var rulesEngine = require('./rules-engine.js');
 var zod = require('./zod.js');
 var strings = require('./primitives/strings.js');
 var arrays = require('./primitives/arrays.js');
@@ -58,6 +59,7 @@ exports.errors = errors;
 exports.contentTypes = contentTypes;
 exports.relations = relations;
 exports.hooks = hooks;
+exports.rulesEngine = rulesEngine;
 exports.validateZod = zod.validateZod;
 exports.strings = strings;
 exports.arrays = arrays;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.mjs

@@ -37,6 +37,8 @@ import * as relations from './relations.mjs';
 export { relations };
 import * as hooks from './hooks.mjs';
 export { hooks };
+import * as rulesEngine from './rules-engine.mjs';
+export { rulesEngine };
 export { validateZod } from './zod.mjs';
 import * as strings from './primitives/strings.mjs';
 export { strings };

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/rules-engine.d.ts

@@ -0,0 +1,24 @@
+import jsonLogic from 'json-logic-js';
+import { z } from 'zod';
+export declare const ConditionSchema: z.ZodObject<{
+    dependsOn: z.ZodString;
+    operator: z.ZodEnum<["is", "isNot"]>;
+    value: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+}, "strip", z.ZodTypeAny, {
+    value: string | number | boolean;
+    dependsOn: string;
+    operator: "is" | "isNot";
+}, {
+    value: string | number | boolean;
+    dependsOn: string;
+    operator: "is" | "isNot";
+}>;
+export type Condition = z.infer<typeof ConditionSchema>;
+export type JsonLogicCondition = jsonLogic.RulesLogic<jsonLogic.AdditionalOperation>;
+export type RulesEngine = {
+    generate: (condition: Condition) => JsonLogicCondition;
+    validate: (condition: Condition) => void;
+    evaluate: (condition: JsonLogicCondition, data: unknown) => boolean;
+};
+export declare function createRulesEngine(): RulesEngine;
+//# sourceMappingURL=rules-engine.d.ts.map

package/dist/rules-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules-engine.d.ts","sourceRoot":"","sources":["../src/rules-engine.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe;;;;;;;;;;;;EAI1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,kBAAkB,GAAG,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC;AACrF,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,CAAC,SAAS,EAAE,SAAS,KAAK,kBAAkB,CAAC;IACvD,QAAQ,EAAE,CAAC,SAAS,EAAE,SAAS,KAAK,IAAI,CAAC;IACzC,QAAQ,EAAE,CAAC,SAAS,EAAE,kBAAkB,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;CACrE,CAAC;AAEF,wBAAgB,iBAAiB,IAAI,WAAW,CAuD/C"}

package/dist/rules-engine.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var jsonLogic = require('json-logic-js');
+var zod = require('zod');
+
+const ConditionSchema = zod.z.object({
+    dependsOn: zod.z.string().min(1),
+    operator: zod.z.enum([
+        'is',
+        'isNot'
+    ]),
+    value: zod.z.union([
+        zod.z.string(),
+        zod.z.number(),
+        zod.z.boolean()
+    ])
+});
+function createRulesEngine() {
+    /**
+   * Transforms a high-level `Condition` object into a JSON Logic-compatible condition.
+   *
+   * Converts operators like 'is' and 'isNot' into their JSON Logic equivalents ('==' and '!=').
+   * Throws an error if the operator is not supported.
+   *
+   * @param condition - The condition object to convert.
+   * @returns A JSON Logic AST representing the condition.
+   * @throws {Error} If the operator is not recognized.
+   */ const generate = (condition)=>{
+        const { dependsOn, operator, value } = condition;
+        const operatorsMap = {
+            is: '==',
+            isNot: '!='
+        };
+        if (!operatorsMap[operator]) {
+            throw new Error(`Invalid operator: ${operator}`);
+        }
+        return {
+            [operatorsMap[operator]]: [
+                {
+                    var: dependsOn
+                },
+                value
+            ]
+        };
+    };
+    /**
+   * Validates a condition object against the `ConditionSchema`.
+   *
+   * Ensures that the condition adheres to the expected structure and types.
+   *
+   * @param condition - The condition object to validate.
+   * @throws {ZodError} If the condition is invalid.
+   */ const validate = (condition)=>{
+        ConditionSchema.parse(condition);
+    };
+    /**
+   * Evaluates a JSON Logic condition against provided data.
+   * @throws {Error} If the condition is invalid.
+   */ const evaluate = (condition, data)=>{
+        try {
+            return jsonLogic.apply(condition, data);
+        } catch (err) {
+            throw new Error(`Invalid condition: ${err.message}`);
+        }
+    };
+    return {
+        generate,
+        validate,
+        evaluate
+    };
+}
+
+exports.ConditionSchema = ConditionSchema;
+exports.createRulesEngine = createRulesEngine;
+//# sourceMappingURL=rules-engine.js.map

package/dist/rules-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules-engine.js","sources":["../src/rules-engine.ts"],"sourcesContent":["import jsonLogic from 'json-logic-js';\nimport { z } from 'zod';\n\nexport const ConditionSchema = z.object({\n  dependsOn: z.string().min(1),\n  operator: z.enum(['is', 'isNot']),\n  value: z.union([z.string(), z.number(), z.boolean()]),\n});\n\nexport type Condition = z.infer<typeof ConditionSchema>;\nexport type JsonLogicCondition = jsonLogic.RulesLogic<jsonLogic.AdditionalOperation>;\nexport type RulesEngine = {\n  generate: (condition: Condition) => JsonLogicCondition;\n  validate: (condition: Condition) => void;\n  evaluate: (condition: JsonLogicCondition, data: unknown) => boolean;\n};\n\nexport function createRulesEngine(): RulesEngine {\n  /**\n   * Transforms a high-level `Condition` object into a JSON Logic-compatible condition.\n   *\n   * Converts operators like 'is' and 'isNot' into their JSON Logic equivalents ('==' and '!=').\n   * Throws an error if the operator is not supported.\n   *\n   * @param condition - The condition object to convert.\n   * @returns A JSON Logic AST representing the condition.\n   * @throws {Error} If the operator is not recognized.\n   */\n  const generate = (condition: Condition): JsonLogicCondition => {\n    const { dependsOn, operator, value } = condition;\n    const operatorsMap = {\n      is: '==',\n      isNot: '!=',\n    };\n    if (!operatorsMap[operator]) {\n      throw new Error(`Invalid operator: ${operator}`);\n    }\n    return { [operatorsMap[operator]]: [{ var: dependsOn }, value] };\n  };\n\n  /**\n   * Validates a condition object against the `ConditionSchema`.\n   *\n   * Ensures that the condition adheres to the expected structure and types.\n   *\n   * @param condition - The condition object to validate.\n   * @throws {ZodError} If the condition is invalid.\n   */\n  const validate = (condition: Condition) => {\n    ConditionSchema.parse(condition);\n  };\n\n  /**\n   * Evaluates a JSON Logic condition against provided data.\n   * @throws {Error} If the condition is invalid.\n   */\n  const evaluate = (\n    condition: jsonLogic.RulesLogic<jsonLogic.AdditionalOperation>,\n    data: unknown\n  ): boolean => {\n    try {\n      return jsonLogic.apply(condition, data);\n    } catch (err: any) {\n      throw new Error(`Invalid condition: ${err.message}`);\n    }\n  };\n\n  return {\n    generate,\n    validate,\n    evaluate,\n  };\n}\n"],"names":["ConditionSchema","z","object","dependsOn","string","min","operator","enum","value","union","number","boolean","createRulesEngine","generate","condition","operatorsMap","is","isNot","Error","var","validate","parse","evaluate","data","jsonLogic","apply","err","message"],"mappings":";;;;;AAGaA,MAAAA,eAAAA,GAAkBC,KAAEC,CAAAA,MAAM,CAAC;AACtCC,IAAAA,SAAAA,EAAWF,KAAEG,CAAAA,MAAM,EAAGC,CAAAA,GAAG,CAAC,CAAA,CAAA;IAC1BC,QAAUL,EAAAA,KAAAA,CAAEM,IAAI,CAAC;AAAC,QAAA,IAAA;AAAM,QAAA;AAAQ,KAAA,CAAA;IAChCC,KAAOP,EAAAA,KAAAA,CAAEQ,KAAK,CAAC;AAACR,QAAAA,KAAAA,CAAEG,MAAM,EAAA;AAAIH,QAAAA,KAAAA,CAAES,MAAM,EAAA;AAAIT,QAAAA,KAAAA,CAAEU,OAAO;AAAG,KAAA;AACtD,CAAG;AAUI,SAASC,iBAAAA,GAAAA;AACd;;;;;;;;;MAUA,MAAMC,WAAW,CAACC,SAAAA,GAAAA;AAChB,QAAA,MAAM,EAAEX,SAAS,EAAEG,QAAQ,EAAEE,KAAK,EAAE,GAAGM,SAAAA;AACvC,QAAA,MAAMC,YAAe,GAAA;YACnBC,EAAI,EAAA,IAAA;YACJC,KAAO,EAAA;AACT,SAAA;AACA,QAAA,IAAI,CAACF,YAAY,CAACT,QAAAA,CAAS,EAAE;AAC3B,YAAA,MAAM,IAAIY,KAAM,CAAA,CAAC,kBAAkB,EAAEZ,SAAS,CAAC,CAAA;AACjD;QACA,OAAO;AAAE,YAAA,CAACS,YAAY,CAACT,QAAS,CAAA,GAAG;AAAC,gBAAA;oBAAEa,GAAKhB,EAAAA;AAAU,iBAAA;AAAGK,gBAAAA;AAAM;AAAC,SAAA;AACjE,KAAA;AAEA;;;;;;;MAQA,MAAMY,WAAW,CAACN,SAAAA,GAAAA;AAChBd,QAAAA,eAAAA,CAAgBqB,KAAK,CAACP,SAAAA,CAAAA;AACxB,KAAA;AAEA;;;MAIA,MAAMQ,QAAW,GAAA,CACfR,SACAS,EAAAA,IAAAA,GAAAA;QAEA,IAAI;YACF,OAAOC,SAAAA,CAAUC,KAAK,CAACX,SAAWS,EAAAA,IAAAA,CAAAA;AACpC,SAAA,CAAE,OAAOG,GAAU,EAAA;YACjB,MAAM,IAAIR,MAAM,CAAC,mBAAmB,EAAEQ,GAAIC,CAAAA,OAAO,CAAC,CAAC,CAAA;AACrD;AACF,KAAA;IAEA,OAAO;AACLd,QAAAA,QAAAA;AACAO,QAAAA,QAAAA;AACAE,QAAAA;AACF,KAAA;AACF;;;;;"}

package/dist/rules-engine.mjs

@@ -0,0 +1,72 @@
+import jsonLogic from 'json-logic-js';
+import { z } from 'zod';
+
+const ConditionSchema = z.object({
+    dependsOn: z.string().min(1),
+    operator: z.enum([
+        'is',
+        'isNot'
+    ]),
+    value: z.union([
+        z.string(),
+        z.number(),
+        z.boolean()
+    ])
+});
+function createRulesEngine() {
+    /**
+   * Transforms a high-level `Condition` object into a JSON Logic-compatible condition.
+   *
+   * Converts operators like 'is' and 'isNot' into their JSON Logic equivalents ('==' and '!=').
+   * Throws an error if the operator is not supported.
+   *
+   * @param condition - The condition object to convert.
+   * @returns A JSON Logic AST representing the condition.
+   * @throws {Error} If the operator is not recognized.
+   */ const generate = (condition)=>{
+        const { dependsOn, operator, value } = condition;
+        const operatorsMap = {
+            is: '==',
+            isNot: '!='
+        };
+        if (!operatorsMap[operator]) {
+            throw new Error(`Invalid operator: ${operator}`);
+        }
+        return {
+            [operatorsMap[operator]]: [
+                {
+                    var: dependsOn
+                },
+                value
+            ]
+        };
+    };
+    /**
+   * Validates a condition object against the `ConditionSchema`.
+   *
+   * Ensures that the condition adheres to the expected structure and types.
+   *
+   * @param condition - The condition object to validate.
+   * @throws {ZodError} If the condition is invalid.
+   */ const validate = (condition)=>{
+        ConditionSchema.parse(condition);
+    };
+    /**
+   * Evaluates a JSON Logic condition against provided data.
+   * @throws {Error} If the condition is invalid.
+   */ const evaluate = (condition, data)=>{
+        try {
+            return jsonLogic.apply(condition, data);
+        } catch (err) {
+            throw new Error(`Invalid condition: ${err.message}`);
+        }
+    };
+    return {
+        generate,
+        validate,
+        evaluate
+    };
+}
+
+export { ConditionSchema, createRulesEngine };
+//# sourceMappingURL=rules-engine.mjs.map

package/dist/rules-engine.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules-engine.mjs","sources":["../src/rules-engine.ts"],"sourcesContent":["import jsonLogic from 'json-logic-js';\nimport { z } from 'zod';\n\nexport const ConditionSchema = z.object({\n  dependsOn: z.string().min(1),\n  operator: z.enum(['is', 'isNot']),\n  value: z.union([z.string(), z.number(), z.boolean()]),\n});\n\nexport type Condition = z.infer<typeof ConditionSchema>;\nexport type JsonLogicCondition = jsonLogic.RulesLogic<jsonLogic.AdditionalOperation>;\nexport type RulesEngine = {\n  generate: (condition: Condition) => JsonLogicCondition;\n  validate: (condition: Condition) => void;\n  evaluate: (condition: JsonLogicCondition, data: unknown) => boolean;\n};\n\nexport function createRulesEngine(): RulesEngine {\n  /**\n   * Transforms a high-level `Condition` object into a JSON Logic-compatible condition.\n   *\n   * Converts operators like 'is' and 'isNot' into their JSON Logic equivalents ('==' and '!=').\n   * Throws an error if the operator is not supported.\n   *\n   * @param condition - The condition object to convert.\n   * @returns A JSON Logic AST representing the condition.\n   * @throws {Error} If the operator is not recognized.\n   */\n  const generate = (condition: Condition): JsonLogicCondition => {\n    const { dependsOn, operator, value } = condition;\n    const operatorsMap = {\n      is: '==',\n      isNot: '!=',\n    };\n    if (!operatorsMap[operator]) {\n      throw new Error(`Invalid operator: ${operator}`);\n    }\n    return { [operatorsMap[operator]]: [{ var: dependsOn }, value] };\n  };\n\n  /**\n   * Validates a condition object against the `ConditionSchema`.\n   *\n   * Ensures that the condition adheres to the expected structure and types.\n   *\n   * @param condition - The condition object to validate.\n   * @throws {ZodError} If the condition is invalid.\n   */\n  const validate = (condition: Condition) => {\n    ConditionSchema.parse(condition);\n  };\n\n  /**\n   * Evaluates a JSON Logic condition against provided data.\n   * @throws {Error} If the condition is invalid.\n   */\n  const evaluate = (\n    condition: jsonLogic.RulesLogic<jsonLogic.AdditionalOperation>,\n    data: unknown\n  ): boolean => {\n    try {\n      return jsonLogic.apply(condition, data);\n    } catch (err: any) {\n      throw new Error(`Invalid condition: ${err.message}`);\n    }\n  };\n\n  return {\n    generate,\n    validate,\n    evaluate,\n  };\n}\n"],"names":["ConditionSchema","z","object","dependsOn","string","min","operator","enum","value","union","number","boolean","createRulesEngine","generate","condition","operatorsMap","is","isNot","Error","var","validate","parse","evaluate","data","jsonLogic","apply","err","message"],"mappings":";;;AAGaA,MAAAA,eAAAA,GAAkBC,CAAEC,CAAAA,MAAM,CAAC;AACtCC,IAAAA,SAAAA,EAAWF,CAAEG,CAAAA,MAAM,EAAGC,CAAAA,GAAG,CAAC,CAAA,CAAA;IAC1BC,QAAUL,EAAAA,CAAAA,CAAEM,IAAI,CAAC;AAAC,QAAA,IAAA;AAAM,QAAA;AAAQ,KAAA,CAAA;IAChCC,KAAOP,EAAAA,CAAAA,CAAEQ,KAAK,CAAC;AAACR,QAAAA,CAAAA,CAAEG,MAAM,EAAA;AAAIH,QAAAA,CAAAA,CAAES,MAAM,EAAA;AAAIT,QAAAA,CAAAA,CAAEU,OAAO;AAAG,KAAA;AACtD,CAAG;AAUI,SAASC,iBAAAA,GAAAA;AACd;;;;;;;;;MAUA,MAAMC,WAAW,CAACC,SAAAA,GAAAA;AAChB,QAAA,MAAM,EAAEX,SAAS,EAAEG,QAAQ,EAAEE,KAAK,EAAE,GAAGM,SAAAA;AACvC,QAAA,MAAMC,YAAe,GAAA;YACnBC,EAAI,EAAA,IAAA;YACJC,KAAO,EAAA;AACT,SAAA;AACA,QAAA,IAAI,CAACF,YAAY,CAACT,QAAAA,CAAS,EAAE;AAC3B,YAAA,MAAM,IAAIY,KAAM,CAAA,CAAC,kBAAkB,EAAEZ,SAAS,CAAC,CAAA;AACjD;QACA,OAAO;AAAE,YAAA,CAACS,YAAY,CAACT,QAAS,CAAA,GAAG;AAAC,gBAAA;oBAAEa,GAAKhB,EAAAA;AAAU,iBAAA;AAAGK,gBAAAA;AAAM;AAAC,SAAA;AACjE,KAAA;AAEA;;;;;;;MAQA,MAAMY,WAAW,CAACN,SAAAA,GAAAA;AAChBd,QAAAA,eAAAA,CAAgBqB,KAAK,CAACP,SAAAA,CAAAA;AACxB,KAAA;AAEA;;;MAIA,MAAMQ,QAAW,GAAA,CACfR,SACAS,EAAAA,IAAAA,GAAAA;QAEA,IAAI;YACF,OAAOC,SAAAA,CAAUC,KAAK,CAACX,SAAWS,EAAAA,IAAAA,CAAAA;AACpC,SAAA,CAAE,OAAOG,GAAU,EAAA;YACjB,MAAM,IAAIR,MAAM,CAAC,mBAAmB,EAAEQ,GAAIC,CAAAA,OAAO,CAAC,CAAC,CAAA;AACrD;AACF,KAAA;IAEA,OAAO;AACLd,QAAAA,QAAAA;AACAO,QAAAA,QAAAA;AACAE,QAAAA;AACF,KAAA;AACF;;;;"}

package/dist/zod.js

@@ -17,11 +17,11 @@ const validateZod = (schema)=>(data)=>{
         }
     };
 const formatZodErrors = (zodError)=>({
-        errors: zodError.format((issue)=>{
+        errors: zodError.errors.map((error)=>{
             return {
-                path: issue.path,
-                message: issue.message,
-                name: issue.code
+                path: error.path,
+                message: error.message,
+                name: 'ValidationError'
             };
         }),
         message: 'Validation error'

package/dist/zod.js.map

@@ -1 +1 @@
-{"version":3,"file":"zod.js","sources":["../src/zod.ts"],"sourcesContent":["import { z } from 'zod';\n\nimport { ValidationError } from './errors';\n\nexport const validateZod =\n  <T extends z.ZodTypeAny>(schema: T) =>\n  (data: unknown): z.TypeOf<T> => {\n    try {\n      return schema.parse(data);\n    } catch (error) {\n      if (error instanceof z.ZodError) {\n        const { message, errors } = formatZodErrors(error);\n        throw new ValidationError(message, { errors });\n      }\n\n      throw error;\n    }\n  };\n\nconst formatZodErrors = (zodError: z.ZodError) => ({\n  errors: zodError.format((issue) => {\n    return {\n      path: issue.path,\n      message: issue.message,\n      name: issue.code,\n    };\n  }),\n  message: 'Validation error',\n});\n"],"names":["validateZod","schema","data","parse","error","z","ZodError","message","errors","formatZodErrors","ValidationError","zodError","format","issue","path","name","code"],"mappings":";;;;;AAIaA,MAAAA,WAAAA,GACX,CAAyBC,MAAAA,GACzB,CAACC,IAAAA,GAAAA;QACC,IAAI;YACF,OAAOD,MAAAA,CAAOE,KAAK,CAACD,IAAAA,CAAAA;AACtB,SAAA,CAAE,OAAOE,KAAO,EAAA;YACd,IAAIA,KAAAA,YAAiBC,KAAEC,CAAAA,QAAQ,EAAE;AAC/B,gBAAA,MAAM,EAAEC,OAAO,UAAEC,QAAM,EAAE,GAAGC,eAAgBL,CAAAA,KAAAA,CAAAA;gBAC5C,MAAM,IAAIM,uBAAgBH,OAAS,EAAA;AAAEC,4BAAAA;AAAO,iBAAA,CAAA;AAC9C;YAEA,MAAMJ,KAAAA;AACR;;AAGJ,MAAMK,eAAAA,GAAkB,CAACE,QAAAA,IAA0B;QACjDH,MAAQG,EAAAA,QAAAA,CAASC,MAAM,CAAC,CAACC,KAAAA,GAAAA;YACvB,OAAO;AACLC,gBAAAA,IAAAA,EAAMD,MAAMC,IAAI;AAChBP,gBAAAA,OAAAA,EAASM,MAAMN,OAAO;AACtBQ,gBAAAA,IAAAA,EAAMF,MAAMG;AACd,aAAA;AACF,SAAA,CAAA;QACAT,OAAS,EAAA;KACX,CAAA;;;;"}
+{"version":3,"file":"zod.js","sources":["../src/zod.ts"],"sourcesContent":["import { z } from 'zod';\n\nimport { ValidationError } from './errors';\n\nexport const validateZod =\n  <T extends z.ZodTypeAny>(schema: T) =>\n  (data: unknown): z.TypeOf<T> => {\n    try {\n      return schema.parse(data);\n    } catch (error) {\n      if (error instanceof z.ZodError) {\n        const { message, errors } = formatZodErrors(error);\n        throw new ValidationError(message, { errors });\n      }\n\n      throw error;\n    }\n  };\n\nconst formatZodErrors = (zodError: z.ZodError) => ({\n  errors: zodError.errors.map((error) => {\n    return {\n      path: error.path,\n      message: error.message,\n      name: 'ValidationError',\n    };\n  }),\n  message: 'Validation error',\n});\n"],"names":["validateZod","schema","data","parse","error","z","ZodError","message","errors","formatZodErrors","ValidationError","zodError","map","path","name"],"mappings":";;;;;AAIaA,MAAAA,WAAAA,GACX,CAAyBC,MAAAA,GACzB,CAACC,IAAAA,GAAAA;QACC,IAAI;YACF,OAAOD,MAAAA,CAAOE,KAAK,CAACD,IAAAA,CAAAA;AACtB,SAAA,CAAE,OAAOE,KAAO,EAAA;YACd,IAAIA,KAAAA,YAAiBC,KAAEC,CAAAA,QAAQ,EAAE;AAC/B,gBAAA,MAAM,EAAEC,OAAO,UAAEC,QAAM,EAAE,GAAGC,eAAgBL,CAAAA,KAAAA,CAAAA;gBAC5C,MAAM,IAAIM,uBAAgBH,OAAS,EAAA;AAAEC,4BAAAA;AAAO,iBAAA,CAAA;AAC9C;YAEA,MAAMJ,KAAAA;AACR;;AAGJ,MAAMK,eAAAA,GAAkB,CAACE,QAAAA,IAA0B;AACjDH,QAAAA,MAAAA,EAAQG,QAASH,CAAAA,MAAM,CAACI,GAAG,CAAC,CAACR,KAAAA,GAAAA;YAC3B,OAAO;AACLS,gBAAAA,IAAAA,EAAMT,MAAMS,IAAI;AAChBN,gBAAAA,OAAAA,EAASH,MAAMG,OAAO;gBACtBO,IAAM,EAAA;AACR,aAAA;AACF,SAAA,CAAA;QACAP,OAAS,EAAA;KACX,CAAA;;;;"}

package/dist/zod.mjs

@@ -15,11 +15,11 @@ const validateZod = (schema)=>(data)=>{
         }
     };
 const formatZodErrors = (zodError)=>({
-        errors: zodError.format((issue)=>{
+        errors: zodError.errors.map((error)=>{
             return {
-                path: issue.path,
-                message: issue.message,
-                name: issue.code
+                path: error.path,
+                message: error.message,
+                name: 'ValidationError'
             };
         }),
         message: 'Validation error'

package/dist/zod.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"zod.mjs","sources":["../src/zod.ts"],"sourcesContent":["import { z } from 'zod';\n\nimport { ValidationError } from './errors';\n\nexport const validateZod =\n  <T extends z.ZodTypeAny>(schema: T) =>\n  (data: unknown): z.TypeOf<T> => {\n    try {\n      return schema.parse(data);\n    } catch (error) {\n      if (error instanceof z.ZodError) {\n        const { message, errors } = formatZodErrors(error);\n        throw new ValidationError(message, { errors });\n      }\n\n      throw error;\n    }\n  };\n\nconst formatZodErrors = (zodError: z.ZodError) => ({\n  errors: zodError.format((issue) => {\n    return {\n      path: issue.path,\n      message: issue.message,\n      name: issue.code,\n    };\n  }),\n  message: 'Validation error',\n});\n"],"names":["validateZod","schema","data","parse","error","z","ZodError","message","errors","formatZodErrors","ValidationError","zodError","format","issue","path","name","code"],"mappings":";;;AAIaA,MAAAA,WAAAA,GACX,CAAyBC,MAAAA,GACzB,CAACC,IAAAA,GAAAA;QACC,IAAI;YACF,OAAOD,MAAAA,CAAOE,KAAK,CAACD,IAAAA,CAAAA;AACtB,SAAA,CAAE,OAAOE,KAAO,EAAA;YACd,IAAIA,KAAAA,YAAiBC,CAAEC,CAAAA,QAAQ,EAAE;AAC/B,gBAAA,MAAM,EAAEC,OAAO,EAAEC,MAAM,EAAE,GAAGC,eAAgBL,CAAAA,KAAAA,CAAAA;gBAC5C,MAAM,IAAIM,gBAAgBH,OAAS,EAAA;AAAEC,oBAAAA;AAAO,iBAAA,CAAA;AAC9C;YAEA,MAAMJ,KAAAA;AACR;;AAGJ,MAAMK,eAAAA,GAAkB,CAACE,QAAAA,IAA0B;QACjDH,MAAQG,EAAAA,QAAAA,CAASC,MAAM,CAAC,CAACC,KAAAA,GAAAA;YACvB,OAAO;AACLC,gBAAAA,IAAAA,EAAMD,MAAMC,IAAI;AAChBP,gBAAAA,OAAAA,EAASM,MAAMN,OAAO;AACtBQ,gBAAAA,IAAAA,EAAMF,MAAMG;AACd,aAAA;AACF,SAAA,CAAA;QACAT,OAAS,EAAA;KACX,CAAA;;;;"}
+{"version":3,"file":"zod.mjs","sources":["../src/zod.ts"],"sourcesContent":["import { z } from 'zod';\n\nimport { ValidationError } from './errors';\n\nexport const validateZod =\n  <T extends z.ZodTypeAny>(schema: T) =>\n  (data: unknown): z.TypeOf<T> => {\n    try {\n      return schema.parse(data);\n    } catch (error) {\n      if (error instanceof z.ZodError) {\n        const { message, errors } = formatZodErrors(error);\n        throw new ValidationError(message, { errors });\n      }\n\n      throw error;\n    }\n  };\n\nconst formatZodErrors = (zodError: z.ZodError) => ({\n  errors: zodError.errors.map((error) => {\n    return {\n      path: error.path,\n      message: error.message,\n      name: 'ValidationError',\n    };\n  }),\n  message: 'Validation error',\n});\n"],"names":["validateZod","schema","data","parse","error","z","ZodError","message","errors","formatZodErrors","ValidationError","zodError","map","path","name"],"mappings":";;;AAIaA,MAAAA,WAAAA,GACX,CAAyBC,MAAAA,GACzB,CAACC,IAAAA,GAAAA;QACC,IAAI;YACF,OAAOD,MAAAA,CAAOE,KAAK,CAACD,IAAAA,CAAAA;AACtB,SAAA,CAAE,OAAOE,KAAO,EAAA;YACd,IAAIA,KAAAA,YAAiBC,CAAEC,CAAAA,QAAQ,EAAE;AAC/B,gBAAA,MAAM,EAAEC,OAAO,EAAEC,MAAM,EAAE,GAAGC,eAAgBL,CAAAA,KAAAA,CAAAA;gBAC5C,MAAM,IAAIM,gBAAgBH,OAAS,EAAA;AAAEC,oBAAAA;AAAO,iBAAA,CAAA;AAC9C;YAEA,MAAMJ,KAAAA;AACR;;AAGJ,MAAMK,eAAAA,GAAkB,CAACE,QAAAA,IAA0B;AACjDH,QAAAA,MAAAA,EAAQG,QAASH,CAAAA,MAAM,CAACI,GAAG,CAAC,CAACR,KAAAA,GAAAA;YAC3B,OAAO;AACLS,gBAAAA,IAAAA,EAAMT,MAAMS,IAAI;AAChBN,gBAAAA,OAAAA,EAASH,MAAMG,OAAO;gBACtBO,IAAM,EAAA;AACR,aAAA;AACF,SAAA,CAAA;QACAP,OAAS,EAAA;KACX,CAAA;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/utils",
-  "version": "5.13.0-beta.1",
+  "version": "5.13.1",
   "description": "Shared utilities for the Strapi packages",
   "keywords": [
     "strapi",
@@ -50,21 +50,23 @@
     "date-fns": "2.30.0",
     "execa": "5.1.1",
     "http-errors": "2.0.0",
+    "json-logic-js": "2.0.5",
     "lodash": "4.17.21",
     "node-machine-id": "1.1.12",
     "p-map": "4.0.0",
     "preferred-pm": "3.1.2",
     "yup": "0.32.9",
-    "zod": "3.24.2"
+    "zod": "^3.22.4"
   },
   "devDependencies": {
     "@types/http-errors": "2.0.4",
+    "@types/json-logic-js": "2.0.8",
     "@types/koa": "2.13.4",
     "@types/node": "18.19.24",
-    "eslint-config-custom": "5.13.0-beta.1",
+    "eslint-config-custom": "5.13.1",
     "koa": "2.15.4",
     "koa-body": "6.0.1",
-    "tsconfig": "5.13.0-beta.1"
+    "tsconfig": "5.13.1"
   },
   "engines": {
     "node": ">=18.0.0 <=22.x.x",

package/dist/machine-id.d.ts

@@ -1,3 +0,0 @@
-declare const _default: () => string;
-export default _default;
-//# sourceMappingURL=machine-id.d.ts.map

package/dist/machine-id.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"machine-id.d.ts","sourceRoot":"","sources":["../src/machine-id.ts"],"names":[],"mappings":";AAGA,wBAQE"}

package/dist/machine-id.js

@@ -1,17 +0,0 @@
-'use strict';
-
-var crypto = require('crypto');
-var nodeMachineId = require('node-machine-id');
-
-var machineId = (()=>{
-    try {
-        const deviceId = nodeMachineId.machineIdSync();
-        return deviceId;
-    } catch (error) {
-        const deviceId = crypto.randomUUID();
-        return deviceId;
-    }
-});
-
-module.exports = machineId;
-//# sourceMappingURL=machine-id.js.map

package/dist/machine-id.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"machine-id.js","sources":["../src/machine-id.ts"],"sourcesContent":["import { randomUUID } from 'crypto';\nimport { machineIdSync } from 'node-machine-id';\n\nexport default () => {\n  try {\n    const deviceId = machineIdSync();\n    return deviceId;\n  } catch (error) {\n    const deviceId = randomUUID();\n    return deviceId;\n  }\n};\n"],"names":["deviceId","machineIdSync","error","randomUUID"],"mappings":";;;;;AAGA,gBAAe,CAAA,IAAA;IACb,IAAI;AACF,QAAA,MAAMA,QAAWC,GAAAA,2BAAAA,EAAAA;QACjB,OAAOD,QAAAA;AACT,KAAA,CAAE,OAAOE,KAAO,EAAA;AACd,QAAA,MAAMF,QAAWG,GAAAA,iBAAAA,EAAAA;QACjB,OAAOH,QAAAA;AACT;AACF,CAAA;;;;"}

package/dist/machine-id.mjs

@@ -1,15 +0,0 @@
-import { randomUUID } from 'crypto';
-import { machineIdSync } from 'node-machine-id';
-
-var machineId = (()=>{
-    try {
-        const deviceId = machineIdSync();
-        return deviceId;
-    } catch (error) {
-        const deviceId = randomUUID();
-        return deviceId;
-    }
-});
-
-export { machineId as default };
-//# sourceMappingURL=machine-id.mjs.map

package/dist/machine-id.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"machine-id.mjs","sources":["../src/machine-id.ts"],"sourcesContent":["import { randomUUID } from 'crypto';\nimport { machineIdSync } from 'node-machine-id';\n\nexport default () => {\n  try {\n    const deviceId = machineIdSync();\n    return deviceId;\n  } catch (error) {\n    const deviceId = randomUUID();\n    return deviceId;\n  }\n};\n"],"names":["deviceId","machineIdSync","error","randomUUID"],"mappings":";;;AAGA,gBAAe,CAAA,IAAA;IACb,IAAI;AACF,QAAA,MAAMA,QAAWC,GAAAA,aAAAA,EAAAA;QACjB,OAAOD,QAAAA;AACT,KAAA,CAAE,OAAOE,KAAO,EAAA;AACd,QAAA,MAAMF,QAAWG,GAAAA,UAAAA,EAAAA;QACjB,OAAOH,QAAAA;AACT;AACF,CAAA;;;;"}