@strapi/utils 5.0.0-rc.9 → 5.0.1

package/dist/index.js

@@ -1335,6 +1335,32 @@ const visitor$7 = ({ schema, key, attribute }, { remove }) => {
     remove(key);
   }
 };
+const MANY_RELATIONS = ["oneToMany", "manyToMany"];
+const getRelationalFields = (contentType) => {
+  return Object.keys(contentType.attributes).filter((attributeName) => {
+    return contentType.attributes[attributeName].type === "relation";
+  });
+};
+const isOneToAny = (attribute) => isRelationalAttribute(attribute) && ["oneToOne", "oneToMany"].includes(attribute.relation);
+const isManyToAny = (attribute) => isRelationalAttribute(attribute) && ["manyToMany", "manyToOne"].includes(attribute.relation);
+const isAnyToOne = (attribute) => isRelationalAttribute(attribute) && ["oneToOne", "manyToOne"].includes(attribute.relation);
+const isAnyToMany = (attribute) => isRelationalAttribute(attribute) && ["oneToMany", "manyToMany"].includes(attribute.relation);
+const constants = {
+  MANY_RELATIONS
+};
+const VALID_RELATION_ORDERING_KEYS = {
+  strict: fp.isBoolean
+};
+const relations = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  VALID_RELATION_ORDERING_KEYS,
+  constants,
+  getRelationalFields,
+  isAnyToMany,
+  isAnyToOne,
+  isManyToAny,
+  isOneToAny
+}, Symbol.toStringTag, { value: "Module" }));
 const ACTIONS_TO_VERIFY$1 = ["find"];
 const { CREATED_BY_ATTRIBUTE: CREATED_BY_ATTRIBUTE$1, UPDATED_BY_ATTRIBUTE: UPDATED_BY_ATTRIBUTE$1 } = constants$1;
 const removeRestrictedRelations = (auth) => async ({ data, key, attribute, schema }, { remove, set }) => {
@@ -1346,19 +1372,57 @@ const removeRestrictedRelations = (auth) => async ({ data, key, attribute, schem
     return;
   }
   const handleMorphRelation = async () => {
-    const newMorphValue = [];
-    for (const element of data[key]) {
+    const elements = data[key];
+    if ("connect" in elements || "set" in elements || "disconnect" in elements) {
+      const newValue = {};
+      const connect = await handleMorphElements(elements.connect || []);
+      const relSet = await handleMorphElements(elements.set || []);
+      const disconnect = await handleMorphElements(elements.disconnect || []);
+      if (connect.length > 0) {
+        newValue.connect = connect;
+      }
+      if (relSet.length > 0) {
+        newValue.set = relSet;
+      }
+      if (disconnect.length > 0) {
+        newValue.disconnect = disconnect;
+      }
+      if ("options" in elements && typeof elements.options === "object" && elements.options !== null) {
+        const filteredOptions = {};
+        Object.keys(elements.options).forEach((key2) => {
+          const validator = VALID_RELATION_ORDERING_KEYS[key2];
+          if (validator && validator(elements.options[key2])) {
+            filteredOptions[key2] = elements.options[key2];
+          }
+        });
+        newValue.options = filteredOptions;
+      }
+      set(key, newValue);
+    } else {
+      const newMorphValue = await handleMorphElements(elements);
+      if (newMorphValue.length === 0) {
+        remove(key);
+      } else {
+        set(key, newMorphValue);
+      }
+    }
+  };
+  const handleMorphElements = async (elements) => {
+    const allowedElements = [];
+    if (!fp.isArray(elements)) {
+      return allowedElements;
+    }
+    for (const element of elements) {
+      if (!fp.isObject(element) || !("__type" in element)) {
+        continue;
+      }
       const scopes = ACTIONS_TO_VERIFY$1.map((action) => `${element.__type}.${action}`);
       const isAllowed = await hasAccessToSomeScopes$1(scopes, auth);
       if (isAllowed) {
-        newMorphValue.push(element);
+        allowedElements.push(element);
       }
     }
-    if (newMorphValue.length === 0) {
-      remove(key);
-    } else {
-      set(key, newMorphValue);
-    }
+    return allowedElements;
   };
   const handleRegularRelation = async () => {
     const scopes = ACTIONS_TO_VERIFY$1.map((action) => `${attribute.target}.${action}`);
@@ -1884,10 +1948,17 @@ const populate = traverseFactory().intercept(isStringArray$1, async (visitor2, o
   }
 });
 const traverseQueryPopulate = fp.curry(populate.traverse);
-const isStringArray = (value) => fp.isArray(value) && value.every(fp.isString);
+const isStringArray = (value) => {
+  return fp.isArray(value) && value.every(fp.isString);
+};
 const fields = traverseFactory().intercept(isStringArray, async (visitor2, options, fields2, { recurse }) => {
   return Promise.all(fields2.map((field) => recurse(visitor2, options, field)));
-}).intercept((value) => fp.eq("*", value), fp.constant("*")).parse(fp.isString, () => ({
+}).intercept(
+  (value) => fp.isString(value) && value.includes(","),
+  (visitor2, options, fields2, { recurse }) => {
+    return Promise.all(fields2.split(",").map((field) => recurse(visitor2, options, field)));
+  }
+).intercept((value) => fp.eq("*", value), fp.constant("*")).parse(fp.isString, () => ({
   transform: fp.trim,
   remove(key, data) {
     return data === key ? void 0 : data;
@@ -2188,6 +2259,15 @@ const throwInvalidKey = ({ key, path }) => {
     path
   });
 };
+const asyncCurry = (fn) => {
+  const curried = (...args) => {
+    if (args.length >= fn.length) {
+      return fn(...args);
+    }
+    return (...moreArgs) => curried(...args, ...moreArgs);
+  };
+  return curried;
+};
 const visitor$3 = ({ key, attribute, path }) => {
   if (attribute?.type === "password") {
     throwInvalidKey({ key, path: path.attribute });
@@ -2213,7 +2293,40 @@ const throwRestrictedRelations = (auth) => async ({ data, key, attribute, schema
     return;
   }
   const handleMorphRelation = async () => {
-    for (const element of data[key]) {
+    const elements = data[key];
+    if ("connect" in elements || "set" in elements || "disconnect" in elements || "options" in elements) {
+      await handleMorphElements(elements.connect || []);
+      await handleMorphElements(elements.set || []);
+      await handleMorphElements(elements.disconnect || []);
+      if ("options" in elements) {
+        if (elements.options === null || elements.options === void 0) {
+          return;
+        }
+        if (typeof elements.options !== "object") {
+          throwInvalidKey({ key, path: path.attribute });
+        }
+        const optionKeys = Object.keys(elements.options);
+        for (const key2 of optionKeys) {
+          if (!(key2 in VALID_RELATION_ORDERING_KEYS)) {
+            throwInvalidKey({ key: key2, path: path.attribute });
+          }
+          if (!VALID_RELATION_ORDERING_KEYS[key2](elements.options[key2])) {
+            throwInvalidKey({ key: key2, path: path.attribute });
+          }
+        }
+      }
+    } else {
+      await handleMorphElements(elements);
+    }
+  };
+  const handleMorphElements = async (elements) => {
+    if (!fp.isArray(elements)) {
+      throwInvalidKey({ key, path: path.attribute });
+    }
+    for (const element of elements) {
+      if (!fp.isObject(element) || !("__type" in element)) {
+        throwInvalidKey({ key, path: path.attribute });
+      }
       const scopes = ACTIONS_TO_VERIFY.map((action) => `${element.__type}.${action}`);
       const isAllowed = await hasAccessToSomeScopes(scopes, auth);
       if (!isAllowed) {
@@ -2353,154 +2466,294 @@ const throwPasswords = (ctx) => async (entity) => {
   }
   return traverseEntity$1(visitor$3, ctx, entity);
 };
-const defaultValidateFilters = fp.curry((ctx, filters2) => {
-  if (!ctx.schema) {
-    throw new Error("Missing schema in defaultValidateFilters");
+const FILTER_TRAVERSALS = [
+  "nonAttributesOperators",
+  "dynamicZones",
+  "morphRelations",
+  "passwords",
+  "private"
+];
+const validateFilters = asyncCurry(
+  async (ctx, filters2, include) => {
+    if (!ctx.schema) {
+      throw new Error("Missing schema in defaultValidateFilters");
+    }
+    const functionsToApply = [];
+    if (include.includes("nonAttributesOperators")) {
+      functionsToApply.push(
+        traverseQueryFilters(({ key, attribute, path }) => {
+          if ([ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE$1].includes(key)) {
+            return;
+          }
+          const isAttribute = !!attribute;
+          if (!isAttribute && !isOperator(key)) {
+            throwInvalidKey({ key, path: path.attribute });
+          }
+        }, ctx)
+      );
+    }
+    if (include.includes("dynamicZones")) {
+      functionsToApply.push(traverseQueryFilters(visitor, ctx));
+    }
+    if (include.includes("morphRelations")) {
+      functionsToApply.push(traverseQueryFilters(visitor$1, ctx));
+    }
+    if (include.includes("passwords")) {
+      functionsToApply.push(traverseQueryFilters(visitor$3, ctx));
+    }
+    if (include.includes("private")) {
+      functionsToApply.push(traverseQueryFilters(visitor$2, ctx));
+    }
+    if (functionsToApply.length === 0) {
+      return filters2;
+    }
+    return pipe(...functionsToApply)(filters2);
   }
-  return pipe(
-    // keys that are not attributes or valid operators
-    traverseQueryFilters(({ key, attribute, path }) => {
-      if ([ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE$1].includes(key)) {
-        return;
-      }
-      const isAttribute = !!attribute;
-      if (!isAttribute && !isOperator(key)) {
-        throwInvalidKey({ key, path: path.attribute });
-      }
-    }, ctx),
-    // dynamic zones from filters
-    traverseQueryFilters(visitor, ctx),
-    // morphTo relations from filters; because you can't have deep filtering on morph relations
-    traverseQueryFilters(visitor$1, ctx),
-    // passwords from filters
-    traverseQueryFilters(visitor$3, ctx),
-    // private from filters
-    traverseQueryFilters(visitor$2, ctx)
-    // we allow empty objects to validate and only sanitize them out, so that users may write "lazy" queries without checking their params exist
-  )(filters2);
+);
+const defaultValidateFilters = asyncCurry(async (ctx, filters2) => {
+  return validateFilters(ctx, filters2, FILTER_TRAVERSALS);
 });
-const defaultValidateSort = fp.curry((ctx, sort2) => {
-  if (!ctx.schema) {
-    throw new Error("Missing schema in defaultValidateSort");
+const SORT_TRAVERSALS = [
+  "nonAttributesOperators",
+  "dynamicZones",
+  "morphRelations",
+  "passwords",
+  "private",
+  "nonScalarEmptyKeys"
+];
+const validateSort = asyncCurry(
+  async (ctx, sort2, include) => {
+    if (!ctx.schema) {
+      throw new Error("Missing schema in defaultValidateSort");
+    }
+    const functionsToApply = [];
+    if (include.includes("nonAttributesOperators")) {
+      functionsToApply.push(
+        traverseQuerySort(({ key, attribute, path }) => {
+          if ([ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE$1].includes(key)) {
+            return;
+          }
+          if (!attribute) {
+            throwInvalidKey({ key, path: path.attribute });
+          }
+        }, ctx)
+      );
+    }
+    if (include.includes("dynamicZones")) {
+      functionsToApply.push(traverseQuerySort(visitor, ctx));
+    }
+    if (include.includes("morphRelations")) {
+      functionsToApply.push(traverseQuerySort(visitor$1, ctx));
+    }
+    if (include.includes("passwords")) {
+      functionsToApply.push(traverseQuerySort(visitor$3, ctx));
+    }
+    if (include.includes("private")) {
+      functionsToApply.push(traverseQuerySort(visitor$2, ctx));
+    }
+    if (include.includes("nonScalarEmptyKeys")) {
+      functionsToApply.push(
+        traverseQuerySort(({ key, attribute, value, path }) => {
+          if ([ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE$1].includes(key)) {
+            return;
+          }
+          if (!isScalarAttribute(attribute) && fp.isEmpty(value)) {
+            throwInvalidKey({ key, path: path.attribute });
+          }
+        }, ctx)
+      );
+    }
+    if (functionsToApply.length === 0) {
+      return sort2;
+    }
+    return pipe(...functionsToApply)(sort2);
   }
-  return pipe(
-    // non attribute keys
-    traverseQuerySort(({ key, attribute, path }) => {
-      if ([ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE$1].includes(key)) {
-        return;
-      }
-      if (!attribute) {
-        throwInvalidKey({ key, path: path.attribute });
-      }
-    }, ctx),
-    // dynamic zones from sort
-    traverseQuerySort(visitor, ctx),
-    // morphTo relations from sort
-    traverseQuerySort(visitor$1, ctx),
-    // private from sort
-    traverseQuerySort(visitor$2, ctx),
-    // passwords from filters
-    traverseQuerySort(visitor$3, ctx),
-    // keys for empty non-scalar values
-    traverseQuerySort(({ key, attribute, value, path }) => {
-      if ([ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE$1].includes(key)) {
-        return;
-      }
-      if (!isScalarAttribute(attribute) && fp.isEmpty(value)) {
-        throwInvalidKey({ key, path: path.attribute });
-      }
-    }, ctx)
-  )(sort2);
+);
+const defaultValidateSort = asyncCurry(async (ctx, sort2) => {
+  return validateSort(ctx, sort2, SORT_TRAVERSALS);
 });
-const defaultValidateFields = fp.curry((ctx, fields2) => {
-  if (!ctx.schema) {
-    throw new Error("Missing schema in defaultValidateFields");
+const FIELDS_TRAVERSALS = ["scalarAttributes", "privateFields", "passwordFields"];
+const validateFields = asyncCurry(
+  async (ctx, fields2, include) => {
+    if (!ctx.schema) {
+      throw new Error("Missing schema in defaultValidateFields");
+    }
+    const functionsToApply = [];
+    if (include.includes("scalarAttributes")) {
+      functionsToApply.push(
+        traverseQueryFields(({ key, attribute, path }) => {
+          if ([ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE$1].includes(key)) {
+            return;
+          }
+          if (fp.isNil(attribute) || !isScalarAttribute(attribute)) {
+            throwInvalidKey({ key, path: path.attribute });
+          }
+        }, ctx)
+      );
+    }
+    if (include.includes("privateFields")) {
+      functionsToApply.push(traverseQueryFields(visitor$2, ctx));
+    }
+    if (include.includes("passwordFields")) {
+      functionsToApply.push(traverseQueryFields(visitor$3, ctx));
+    }
+    if (functionsToApply.length === 0) {
+      return fields2;
+    }
+    return pipe(...functionsToApply)(fields2);
   }
-  return pipe(
-    // Only allow scalar attributes
-    traverseQueryFields(({ key, attribute, path }) => {
-      if ([ID_ATTRIBUTE$1, DOC_ID_ATTRIBUTE$1].includes(key)) {
-        return;
-      }
-      if (fp.isNil(attribute) || !isScalarAttribute(attribute)) {
-        throwInvalidKey({ key, path: path.attribute });
-      }
-    }, ctx),
-    // private fields
-    traverseQueryFields(visitor$2, ctx),
-    // password fields
-    traverseQueryFields(visitor$3, ctx)
-  )(fields2);
+);
+const defaultValidateFields = asyncCurry(async (ctx, fields2) => {
+  return validateFields(ctx, fields2, FIELDS_TRAVERSALS);
 });
-const defaultValidatePopulate = fp.curry((ctx, populate2) => {
+const POPULATE_TRAVERSALS = ["nonAttributesOperators", "private"];
+const validatePopulate = asyncCurry(
+  async (ctx, populate2, includes) => {
+    if (!ctx.schema) {
+      throw new Error("Missing schema in defaultValidatePopulate");
+    }
+    const functionsToApply = [];
+    functionsToApply.push(
+      traverseQueryPopulate(async ({ key, path, value, schema, attribute, getModel }, { set }) => {
+        if (attribute) {
+          const isPopulatableAttribute = ["relation", "dynamiczone", "component", "media"].includes(
+            attribute.type
+          );
+          if (!isPopulatableAttribute) {
+            throwInvalidKey({ key, path: path.raw });
+          }
+          return;
+        }
+        if (key === "on") {
+          if (!fp.isObject(value)) {
+            return throwInvalidKey({ key, path: path.raw });
+          }
+          const targets = Object.keys(value);
+          for (const target of targets) {
+            const model = getModel(target);
+            if (!model) {
+              throwInvalidKey({ key: target, path: `${path.raw}.${target}` });
+            }
+          }
+          return;
+        }
+        if (key === "" && value === "*") {
+          return;
+        }
+        if (key === "count") {
+          try {
+            parseType({ type: "boolean", value });
+            return;
+          } catch {
+            throwInvalidKey({ key, path: path.attribute });
+          }
+        }
+        try {
+          parseType({ type: "boolean", value: key });
+          return;
+        } catch {
+        }
+        if (key === "sort") {
+          set(
+            key,
+            await validateSort(
+              {
+                schema,
+                getModel
+              },
+              value,
+              // pass the sort value
+              includes?.sort || SORT_TRAVERSALS
+            )
+          );
+          return;
+        }
+        if (key === "filters") {
+          set(
+            key,
+            await validateFilters(
+              {
+                schema,
+                getModel
+              },
+              value,
+              // pass the filters value
+              includes?.filters || FILTER_TRAVERSALS
+            )
+          );
+          return;
+        }
+        if (key === "fields") {
+          set(
+            key,
+            await validateFields(
+              {
+                schema,
+                getModel
+              },
+              value,
+              // pass the fields value
+              includes?.fields || FIELDS_TRAVERSALS
+            )
+          );
+          return;
+        }
+        if (key === "populate") {
+          set(
+            key,
+            await validatePopulate(
+              {
+                schema,
+                getModel
+              },
+              value,
+              // pass the nested populate value
+              includes
+              // pass down the same includes object
+            )
+          );
+          return;
+        }
+        if (includes?.populate?.includes("nonAttributesOperators")) {
+          throwInvalidKey({ key, path: path.attribute });
+        }
+      }, ctx)
+    );
+    if (includes?.populate?.includes("private")) {
+      functionsToApply.push(traverseQueryPopulate(visitor$2, ctx));
+    }
+    if (functionsToApply.length === 0) {
+      return populate2;
+    }
+    return pipe(...functionsToApply)(populate2);
+  }
+);
+const defaultValidatePopulate = asyncCurry(async (ctx, populate2) => {
   if (!ctx.schema) {
     throw new Error("Missing schema in defaultValidatePopulate");
   }
-  return pipe(
-    traverseQueryPopulate(async ({ key, value, schema, attribute, getModel }, { set }) => {
-      if (attribute) {
-        return;
-      }
-      if (key === "sort") {
-        set(
-          key,
-          await defaultValidateSort(
-            {
-              schema,
-              getModel
-            },
-            value
-          )
-        );
-      }
-      if (key === "filters") {
-        set(
-          key,
-          await defaultValidateFilters(
-            {
-              schema,
-              getModel
-            },
-            value
-          )
-        );
-      }
-      if (key === "fields") {
-        set(
-          key,
-          await defaultValidateFields(
-            {
-              schema,
-              getModel
-            },
-            value
-          )
-        );
-      }
-      if (key === "populate") {
-        set(
-          key,
-          await defaultValidatePopulate(
-            {
-              schema,
-              getModel
-            },
-            value
-          )
-        );
-      }
-    }, ctx),
-    // Remove private fields
-    traverseQueryPopulate(visitor$2, ctx)
-  )(populate2);
+  return validatePopulate(ctx, populate2, {
+    filters: FILTER_TRAVERSALS,
+    sort: SORT_TRAVERSALS,
+    fields: FIELDS_TRAVERSALS,
+    populate: POPULATE_TRAVERSALS
+  });
 });
 const validators = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  FIELDS_TRAVERSALS,
+  FILTER_TRAVERSALS,
+  POPULATE_TRAVERSALS,
+  SORT_TRAVERSALS,
   defaultValidateFields,
   defaultValidateFilters,
   defaultValidatePopulate,
   defaultValidateSort,
-  throwPasswords
+  throwPasswords,
+  validateFields,
+  validateFilters,
+  validatePopulate,
+  validateSort
 }, Symbol.toStringTag, { value: "Module" }));
 const { ID_ATTRIBUTE, DOC_ID_ATTRIBUTE } = constants$1;
 const createAPIValidators = (opts) => {
@@ -2555,24 +2808,24 @@ const createAPIValidators = (opts) => {
     }
     const { filters: filters2, sort: sort2, fields: fields2, populate: populate2 } = query;
     if (filters2) {
-      await validateFilters(filters2, schema, { auth });
+      await validateFilters2(filters2, schema, { auth });
     }
     if (sort2) {
-      await validateSort(sort2, schema, { auth });
+      await validateSort2(sort2, schema, { auth });
     }
     if (fields2) {
-      await validateFields(fields2, schema);
+      await validateFields2(fields2, schema);
     }
     if (populate2 && populate2 !== "*") {
-      await validatePopulate(populate2, schema);
+      await validatePopulate2(populate2, schema);
     }
   };
-  const validateFilters = async (filters2, schema, { auth } = {}) => {
+  const validateFilters2 = async (filters2, schema, { auth } = {}) => {
     if (!schema) {
       throw new Error("Missing schema in validateFilters");
     }
     if (fp.isArray(filters2)) {
-      await Promise.all(filters2.map((filter) => validateFilters(filter, schema, { auth })));
+      await Promise.all(filters2.map((filter) => validateFilters2(filter, schema, { auth })));
       return;
     }
     const transforms = [defaultValidateFilters({ schema, getModel })];
@@ -2594,7 +2847,7 @@ const createAPIValidators = (opts) => {
       throw e;
     }
   };
-  const validateSort = async (sort2, schema, { auth } = {}) => {
+  const validateSort2 = async (sort2, schema, { auth } = {}) => {
     if (!schema) {
       throw new Error("Missing schema in validateSort");
     }
@@ -2617,7 +2870,7 @@ const createAPIValidators = (opts) => {
       throw e;
     }
   };
-  const validateFields = async (fields2, schema) => {
+  const validateFields2 = async (fields2, schema) => {
     if (!schema) {
       throw new Error("Missing schema in validateFields");
     }
@@ -2632,7 +2885,7 @@ const createAPIValidators = (opts) => {
       throw e;
     }
   };
-  const validatePopulate = async (populate2, schema, { auth } = {}) => {
+  const validatePopulate2 = async (populate2, schema, { auth } = {}) => {
     if (!schema) {
       throw new Error("Missing schema in sanitizePopulate");
     }
@@ -2658,10 +2911,10 @@ const createAPIValidators = (opts) => {
   return {
     input: validateInput,
     query: validateQuery,
-    filters: validateFilters,
-    sort: validateSort,
-    fields: validateFields,
-    populate: validatePopulate
+    filters: validateFilters2,
+    sort: validateSort2,
+    fields: validateFields2,
+    populate: validatePopulate2
   };
 };
 const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -3118,28 +3371,6 @@ const yup = /* @__PURE__ */ _mergeNamespaces({
   StrapiIDSchema,
   strapiID
 }, [yup__namespace]);
-const MANY_RELATIONS = ["oneToMany", "manyToMany"];
-const getRelationalFields = (contentType) => {
-  return Object.keys(contentType.attributes).filter((attributeName) => {
-    return contentType.attributes[attributeName].type === "relation";
-  });
-};
-const isOneToAny = (attribute) => isRelationalAttribute(attribute) && ["oneToOne", "oneToMany"].includes(attribute.relation);
-const isManyToAny = (attribute) => isRelationalAttribute(attribute) && ["manyToMany", "manyToOne"].includes(attribute.relation);
-const isAnyToOne = (attribute) => isRelationalAttribute(attribute) && ["oneToOne", "manyToOne"].includes(attribute.relation);
-const isAnyToMany = (attribute) => isRelationalAttribute(attribute) && ["oneToMany", "manyToMany"].includes(attribute.relation);
-const constants = {
-  MANY_RELATIONS
-};
-const relations = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  constants,
-  getRelationalFields,
-  isAnyToMany,
-  isAnyToOne,
-  isManyToAny,
-  isOneToAny
-}, Symbol.toStringTag, { value: "Module" }));
 const validateZod = (schema) => (data) => {
   try {
     return schema.parse(data);