@rebasepro/common 0.0.1-canary.0 → 0.0.1-canary.0e2f892

package/dist/index.es.js

@@ -1,299 +1,17 @@
-import { GeoPoint, EntityReference, EntityRelation } from "@rebasepro/types";
-import hash from "object-hash";
+import { EntityReference, EntityRelation, getDataSourceCapabilities } from "@rebasepro/types";
+import { mergeDeep, getIn as getIn$1, isDefaultFieldConfigId, randomString, toSnakeCase, generateForeignKeyName, removeFunctions } from "@rebasepro/utils";
 import jsonLogic from "json-logic-js";
 import { deepEqual } from "fast-equals";
 import cloneDeep from "lodash/cloneDeep.js";
 const DEFAULT_ONE_OF_TYPE = "type";
 const DEFAULT_ONE_OF_VALUE = "value";
-const isEmptyArray = (value) => Array.isArray(value) && value.length === 0;
-const isFunction = (obj) => typeof obj === "function";
-const isInteger = (obj) => String(Math.floor(Number(obj))) === String(obj);
-const isNaN$1 = (obj) => obj !== obj;
-function getIn$1(obj, key, def, p = 0) {
-  const path = toPath(key);
-  while (obj && p < path.length) {
-    obj = obj[path[p++]];
-  }
-  if (p !== path.length && !obj) {
-    return def;
-  }
-  return obj === void 0 ? def : obj;
-}
-function setIn(obj, path, value) {
-  const res = clone(obj);
-  let resVal = res;
-  let i = 0;
-  const pathArray = toPath(path);
-  for (; i < pathArray.length - 1; i++) {
-    const currentPath = pathArray[i];
-    const currentObj = getIn$1(obj, pathArray.slice(0, i + 1));
-    if (currentObj && (isObject(currentObj) || Array.isArray(currentObj))) {
-      resVal = resVal[currentPath] = clone(currentObj);
-    } else {
-      const nextPath = pathArray[i + 1];
-      resVal = resVal[currentPath] = isInteger(nextPath) && Number(nextPath) >= 0 ? [] : {};
-    }
-  }
-  if ((i === 0 ? obj : resVal)[pathArray[i]] === value) {
-    return obj;
-  }
-  if (value === void 0) {
-    delete resVal[pathArray[i]];
-  } else {
-    resVal[pathArray[i]] = value;
-  }
-  if (i === 0 && value === void 0) {
-    delete res[pathArray[i]];
-  }
-  return res;
-}
-function clone(value) {
-  if (Array.isArray(value)) {
-    return [...value];
-  } else if (typeof value === "object" && value !== null) {
-    return {
-      ...value
-    };
-  } else {
-    return value;
-  }
-}
-function toPath(value) {
-  if (Array.isArray(value)) return value;
-  return value.replace(/\[(\d+)]/g, ".$1").replace(/^\./, "").replace(/\.$/, "").split(".");
-}
-const pick = (obj, ...args) => ({
-  ...args.reduce((res, key) => ({
-    ...res,
-    [key]: obj[key]
-  }), {})
-});
-function isObject(item) {
-  return !!item && typeof item === "object" && !Array.isArray(item);
-}
-function isPlainObject(obj) {
-  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(obj);
-  return proto === Object.prototype;
-}
-function mergeDeep(target, source, ignoreUndefined = false) {
-  if (!isObject(target)) {
-    return target;
-  }
-  const output = {
-    ...target
-  };
-  if (!isObject(source)) {
-    return output;
-  }
-  for (const key in source) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      const sourceValue = source[key];
-      const outputValue = output[key];
-      if (ignoreUndefined && sourceValue === void 0) {
-        continue;
-      }
-      if (sourceValue instanceof Date) {
-        output[key] = new Date(sourceValue.getTime());
-      } else if (Array.isArray(sourceValue)) {
-        if (Array.isArray(outputValue)) {
-          const newArray = [];
-          const maxLength = Math.max(outputValue.length, sourceValue.length);
-          for (let i = 0; i < maxLength; i++) {
-            const sourceItem = sourceValue[i];
-            const targetItem = outputValue[i];
-            if (i >= sourceValue.length) {
-              newArray[i] = targetItem;
-            } else if (i >= outputValue.length) {
-              newArray[i] = sourceItem;
-            } else if (sourceItem === null) {
-              newArray[i] = targetItem;
-            } else if (isPlainObject(sourceItem) && isPlainObject(targetItem)) {
-              newArray[i] = mergeDeep(targetItem, sourceItem, ignoreUndefined);
-            } else {
-              newArray[i] = sourceItem;
-            }
-          }
-          output[key] = newArray;
-        } else {
-          output[key] = [...sourceValue];
-        }
-      } else if (isPlainObject(sourceValue)) {
-        if (isPlainObject(outputValue)) {
-          output[key] = mergeDeep(outputValue, sourceValue, ignoreUndefined);
-        } else {
-          output[key] = sourceValue;
-        }
-      } else if (isObject(sourceValue)) {
-        output[key] = sourceValue;
-      } else {
-        output[key] = sourceValue;
-      }
-    }
-  }
-  return output;
-}
-function getValueInPath(o, path) {
-  if (!o) return void 0;
-  if (typeof o === "object") {
-    if (path in o) {
-      return o[path];
-    }
-    if (path.includes(".") || path.includes("[")) {
-      let pathSegments = path.split(/[.[]/);
-      if (path.includes("[")) {
-        pathSegments = pathSegments.map((segment) => segment.replace("]", ""));
-      }
-      const firstSegment = pathSegments[0];
-      const isArrayAndIndexExists = Array.isArray(o[firstSegment]) && !isNaN$1(parseInt(pathSegments[1]));
-      const nextObject = isArrayAndIndexExists ? o[firstSegment][parseInt(pathSegments[1])] : o[firstSegment];
-      const nextPath = pathSegments.slice(isArrayAndIndexExists ? 2 : 1).join(".");
-      if (nextPath === "") return nextObject;
-      return getValueInPath(nextObject, nextPath);
-    }
-  }
-  return void 0;
-}
-function removeInPath(o, path) {
-  let currentObject = {
-    ...o
-  };
-  const parts = path.split(".");
-  const last = parts.pop();
-  for (const part of parts) {
-    currentObject = currentObject[part];
-  }
-  if (last) delete currentObject[last];
-  return currentObject;
-}
-function removeFunctions(o) {
-  if (o === void 0) return void 0;
-  if (o === null) return null;
-  if (typeof o === "object") {
-    if (Array.isArray(o)) {
-      return o.map((v) => removeFunctions(v));
-    }
-    if (!isPlainObject(o)) {
-      return o;
-    }
-    return Object.entries(o).filter(([_, value]) => typeof value !== "function").map(([key, value]) => {
-      if (Array.isArray(value)) {
-        return {
-          [key]: value.map((v) => removeFunctions(v))
-        };
-      } else if (typeof value === "object") {
-        return {
-          [key]: removeFunctions(value)
-        };
-      } else return {
-        [key]: value
-      };
-    }).reduce((a, b) => ({
-      ...a,
-      ...b
-    }), {});
-  }
-  return o;
-}
-function getHashValue(v) {
-  if (!v) return null;
-  if (typeof v === "object" && v !== null) {
-    if ("id" in v) return String(v.id);
-    else if (v instanceof Date) return v.toLocaleString();
-    else if (v instanceof GeoPoint) return hash(v);
-  }
-  return hash(v, {
-    ignoreUnknown: true
-  });
-}
-function removeUndefined(value, removeEmptyStrings) {
-  if (typeof value === "function") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((v) => removeUndefined(v, removeEmptyStrings));
-  }
-  if (typeof value === "object") {
-    if (value === null) return value;
-    if (!isPlainObject(value)) {
-      return value;
-    }
-    const res = {};
-    Object.keys(value).forEach((key) => {
-      if (!isEmptyObject(value)) {
-        const childRes = removeUndefined(value[key], removeEmptyStrings);
-        const isString = typeof childRes === "string";
-        const shouldKeepIfString = !removeEmptyStrings || removeEmptyStrings && !isString || removeEmptyStrings && isString && childRes !== "";
-        if (childRes !== void 0 && !isEmptyObject(childRes) && shouldKeepIfString) res[key] = childRes;
-      }
-    });
-    return res;
-  }
-  return value;
-}
-function removeNulls(value) {
-  if (typeof value === "function") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((v) => removeNulls(v));
-  }
-  if (typeof value === "object") {
-    if (value === null) return value;
-    if (!isPlainObject(value)) {
-      return value;
-    }
-    const res = {};
-    const obj = value;
-    Object.keys(obj).forEach((key) => {
-      if (obj[key] !== null) res[key] = removeNulls(obj[key]);
-    });
-    return res;
-  }
-  return value;
-}
-function isEmptyObject(obj) {
-  return obj && Object.getPrototypeOf(obj) === Object.prototype && Object.keys(obj).length === 0;
-}
-function removePropsIfExisting(source, comparison) {
-  const isObject2 = (val) => typeof val === "object" && val !== null;
-  const isArray = (val) => Array.isArray(val);
-  if (!isObject2(source) || !isObject2(comparison)) {
-    return source;
-  }
-  const res = isArray(source) ? [...source] : {
-    ...source
-  };
-  if (isArray(res)) {
-    for (let i = res.length - 1; i >= 0; i--) {
-      if (res[i] === comparison[i]) {
-        res.splice(i, 1);
-      } else if (isObject2(res[i]) && isObject2(comparison[i])) {
-        res[i] = removePropsIfExisting(res[i], comparison[i]);
-      }
-    }
-  } else {
-    Object.keys(comparison).forEach((key) => {
-      if (key in res) {
-        if (isObject2(res[key]) && isObject2(comparison[key])) {
-          res[key] = removePropsIfExisting(res[key], comparison[key]);
-        } else if (res[key] === comparison[key]) {
-          delete res[key];
-        }
-      }
-    });
-  }
-  return res;
-}
 function isReadOnly(property) {
   if (property.readOnly) return true;
   if (property.type === "date") {
     if (property.autoValue) return true;
   }
   if (property.type === "reference") {
-    return !property.path && !property.Field;
+    return !property.path && !("Field" in property && property.Field);
   }
   return false;
 }
@@ -379,12 +97,20 @@ function getReferenceFrom(entity) {
   return new EntityReference({
     id: entity.id,
     path: entity.path,
-    datasource: entity.datasource,
+    driver: entity.driver,
     databaseId: entity.databaseId
   });
 }
 function getRelationFrom(entity) {
-  return new EntityRelation(entity.id, entity.path);
+  return new EntityRelation(entity.id, entity.path, entity);
+}
+function normalizeToEntityRelation(value) {
+  if (value instanceof EntityRelation) return value;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const obj = value;
+  const isRelationLike = obj.__type === "relation" || obj.__type === "reference" || typeof obj.isEntityRelation === "function" && obj.isEntityRelation() || typeof obj.isEntityReference === "function" && obj.isEntityReference();
+  if (!isRelationLike) return null;
+  return new EntityRelation(obj.id, obj.path, obj.data);
 }
 function traverseValuesProperties(inputValues, properties, operation) {
   const safeInputValues = inputValues ?? {};
@@ -440,6 +166,21 @@ function traverseValueProperty(inputValue, property, operation) {
   }
   return value;
 }
+function createRelationRef(id, path) {
+  return {
+    id,
+    path,
+    __type: "relation"
+  };
+}
+function createRelationRefWithData(id, path, data) {
+  return {
+    id,
+    path,
+    __type: "relation",
+    data
+  };
+}
 function sortProperties(properties, propertiesOrder) {
   try {
     const propertiesKeys = Object.keys(properties);
@@ -538,58 +279,6 @@ function getPrimaryKeys(collection) {
   }
   return ["id"];
 }
-const kebabCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
-const toKebabCase = (str) => {
-  const regExpMatchArray = str.match(kebabCaseRegex);
-  if (!regExpMatchArray) return "";
-  return regExpMatchArray.map((x) => x.toLowerCase()).join("-");
-};
-const snakeCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
-const toSnakeCase = (str) => {
-  const regExpMatchArray = str.match(snakeCaseRegex);
-  if (!regExpMatchArray) return "";
-  return regExpMatchArray.map((x) => x.toLowerCase()).join("_");
-};
-function randomString(strLength = 5) {
-  return Math.random().toString(36).slice(2, 2 + strLength);
-}
-function randomColor() {
-  return Math.floor(Math.random() * 16777215).toString(16);
-}
-function slugify(text, separator = "_", lowercase = true) {
-  if (!text) return "";
-  const from = "ãàáäâẽèéëêìíïîõòóöôùúüûñç·/_,:;-";
-  const to = `aaaaaeeeeeiiiiooooouuuunc${separator}${separator}${separator}${separator}${separator}${separator}${separator}`;
-  for (let i = 0, l = from.length; i < l; i++) {
-    text = text.replace(new RegExp(from.charAt(i), "g"), to.charAt(i));
-  }
-  text = text.toString().replace(/\s+/g, separator).replace(/&/g, separator).replace(/[^\w\\-]+/g, "").replace(new RegExp("\\" + separator + "\\" + separator + "+", "g"), separator).trim().replace(/^\s+|\s+$/g, "");
-  return lowercase ? text.toLowerCase() : text;
-}
-function unslugify(slug) {
-  if (!slug) return "";
-  if (slug.includes("-") || slug.includes("_") || !slug.includes(" ")) {
-    const result = slug.replace(/[-_]/g, " ");
-    return result.replace(/\w\S*/g, function(txt) {
-      return txt.charAt(0).toUpperCase() + txt.substring(1);
-    }).trim();
-  } else {
-    return slug.trim();
-  }
-}
-function prettifyIdentifier(input) {
-  if (!input) return "";
-  let text = input;
-  text = text.replace(/([a-z])([A-Z])|([A-Z])([A-Z][a-z])/g, "$1$3 $2$4");
-  text = text.replace(/[_-]+/g, " ");
-  const s = text.trim().replace(/\b\w/g, (char) => char.toUpperCase());
-  console.log("Prettified identifier:", {
-    input,
-    s
-  });
-  return s;
-}
-const defaultDateFormat = "MMMM dd, yyyy, HH:mm:ss";
 function enumToObjectEntries(enumValues) {
   if (Array.isArray(enumValues)) {
     return enumValues;
@@ -624,28 +313,6 @@ function segmentsToStrippedPath(paths) {
 function fullPathToCollectionSegments(path) {
   return path.split("/").filter((e, i) => i % 2 === 0);
 }
-function serializeRegExp(input) {
-  if (!input) return "";
-  return input.toString();
-}
-function hydrateRegExp(input) {
-  if (!input) return void 0;
-  const fragments = input.match(/\/(.*?)\/([a-z]*)?$/i);
-  if (fragments) {
-    return new RegExp(fragments[1], fragments[2] || "");
-  } else {
-    return new RegExp(input, "");
-  }
-}
-function isValidRegExp(input) {
-  const fullRegexp = input.match(/\/((?![*+?])(?:[^\r\n[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*])+)\/((?:g(?:im?|mi?)?|i(?:gm?|mg?)?|m(?:gi?|ig?)?)?)/);
-  if (fullRegexp) return true;
-  const simpleRegexp = input.match(/((?![*+?])(?:[^\r\n[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*])+)/);
-  return !!simpleRegexp;
-}
-function isDefaultFieldConfigId(id) {
-  return ["text_field", "multiline", "markdown", "url", "email", "switch", "select", "multi_select", "number_input", "number_select", "multi_number_select", "file_upload", "multi_file_upload", "reference_as_string", "reference", "multi_references", "relation", "date_time", "group", "key_value", "repeat", "custom_array", "block"].includes(id);
-}
 function resolveProperty(props) {
   const {
     property,
@@ -655,22 +322,24 @@ function resolveProperty(props) {
   let resultProperty;
   if (isPropertyBuilder(property)) {
     const path = rest.path;
-    if (!path) throw Error("Trying to resolve a property builder without specifying the entity path");
-    const usedPropertyValue = rest.propertyKey ? getIn$1(rest.values, rest.propertyKey) : void 0;
-    const dynamicProps = property.dynamicProps?.({
-      ...rest,
-      path,
-      propertyValue: usedPropertyValue,
-      values: rest.values ?? {},
-      previousValues: rest.previousValues ?? rest.values ?? {}
-    });
-    resultProperty = mergeDeep(property, dynamicProps ?? {});
+    if (!path) {
+      resultProperty = property;
+    } else {
+      const usedPropertyValue = rest.propertyKey ? getIn$1(rest.values, rest.propertyKey) : void 0;
+      const dynamicProps = property.dynamicProps?.({
+        ...rest,
+        path,
+        propertyValue: usedPropertyValue,
+        values: rest.values ?? {},
+        previousValues: rest.previousValues ?? rest.values ?? {}
+      });
+      resultProperty = mergeDeep(property, dynamicProps ?? {});
+    }
   } else {
     resultProperty = property;
   }
-  if (resultProperty.dynamicProps) {
+  if (resultProperty?.dynamicProps && rest.path) {
     const path = rest.path;
-    if (!path) throw Error("Trying to resolve dynamicProps without specifying the entity path");
     const usedPropertyValue = rest.propertyKey ? getIn$1(rest.values, rest.propertyKey) : void 0;
     const dynamicPropsResult = resultProperty.dynamicProps({
       ...rest,
@@ -712,10 +381,10 @@ function resolveProperty(props) {
       return resolvedProperty;
     }
     if (customField.property) {
-      const {
-        propertyConfig: _unused,
-        ...restConfigProperty
-      } = customField.property;
+      const restConfigProperty = {
+        ...customField.property
+      };
+      delete restConfigProperty.propertyConfig;
       const customFieldProperty = resolveProperty({
         property: {
           name: "",
@@ -731,10 +400,14 @@ function resolveProperty(props) {
   }
   return resolvedProperty;
 }
-function resolveRelationProperty(property, relations) {
-  const relation = relations.find((rel) => rel.relationName === property.relationName);
+function resolveRelationProperty(property, relations, propertyKey) {
+  if (property.relation) {
+    return property;
+  }
+  const name = property.relationName || propertyKey;
+  const relation = name ? relations.find((rel) => rel.relationName === name) : void 0;
   if (!relation) {
-    throw Error(`Relation ${property.relationName} not found`);
+    throw Error(`Relation ${name ?? "(unnamed)"} not found`);
   }
   return {
     ...property,
@@ -827,7 +500,7 @@ function resolveArrayProperties({
       });
     }).filter((e) => Boolean(e)) : [];
     return resolvedProperties;
-  } else if (!property.Field) {
+  } else if (!("Field" in property && property.Field)) {
     throw Error(`The array property (${propertyKey}) needs to declare an 'of' or a 'oneOf' property, or provide a custom \`Field\` component`);
   } else {
     return [];
@@ -862,209 +535,41 @@ function resolveEnumValues(input) {
     return void 0;
   }
 }
-function resolveEntityView$1(entityView, contextEntityViews) {
-  if (typeof entityView === "string") {
-    return contextEntityViews?.find((entry) => entry.key === entityView);
-  } else {
-    return entityView;
-  }
-}
-function resolveEntityAction(entityAction, contextEntityActions) {
-  if (typeof entityAction === "string") {
-    return contextEntityActions?.find((entry) => entry.key === entityAction);
-  } else {
-    return entityAction;
-  }
-}
-function resolvedSelectedEntityView(customViews, customizationController, selectedTab, canEdit) {
-  const resolvedEntityViews = customViews ? customViews.map((e) => resolveEntityView$1(e, customizationController.entityViews)).filter((e) => Boolean(e)) : [];
-  const selectedEntityView = resolvedEntityViews.find((e) => e.key === selectedTab);
-  const selectedSecondaryForm = customViews && resolvedEntityViews.filter((e) => e.includeActions).find((e) => e.key === selectedTab);
-  return {
-    resolvedEntityViews,
-    selectedEntityView,
-    selectedSecondaryForm
-  };
-}
 function getSubcollections(collection) {
-  const subcollections = [];
-  subcollections.push(...collection.subcollections?.() ?? []);
-  subcollections.push(...(collection.relations ?? []).filter((rel) => rel.cardinality === "many").map((relation) => {
-    const targetCollection = relation.target();
-    const overrides = relation.overrides;
-    return overrides ? mergeDeep(targetCollection, overrides) : targetCollection;
-  }) ?? []);
-  return subcollections;
-}
-function removeInitialAndTrailingSlashes(s) {
-  return removeInitialSlash(removeTrailingSlash(s));
-}
-function removeInitialSlash(s) {
-  if (s.startsWith("/")) return s.slice(1);
-  else return s;
-}
-function removeTrailingSlash(s) {
-  if (s.endsWith("/")) return s.slice(0, -1);
-  else return s;
-}
-function addInitialSlash(s) {
-  if (s.startsWith("/")) return s;
-  else return `/${s}`;
-}
-function getLastSegment(path) {
-  const cleanPath = removeInitialAndTrailingSlashes(path);
-  if (cleanPath.includes("/")) {
-    const segments = cleanPath.split("/");
-    return segments[segments.length - 1];
-  }
-  return cleanPath;
-}
-function resolveCollectionPathIds(path, allCollections) {
-  let remainingPath = removeInitialAndTrailingSlashes(path);
-  if (!remainingPath) {
-    return "";
-  }
-  let currentCollections = allCollections;
-  const resolvedPathParts = [];
-  while (remainingPath.length > 0) {
-    if (!currentCollections || currentCollections.length === 0) {
-      console.warn(`resolveCollectionPathIds: Path structure implies subcollections, but none found before segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
-      resolvedPathParts.push(remainingPath);
-      remainingPath = "";
-      break;
-    }
-    let foundMatch = false;
-    const potentialMatches = currentCollections.flatMap((col) => [{
-      col,
-      match: col.slug
-    }]).filter((p) => p.match && remainingPath.startsWith(p.match)).sort((a, b) => b.match.length - a.match.length);
-    if (potentialMatches.length > 0) {
-      const {
-        col: foundCollection,
-        match: matchString
-      } = potentialMatches[0];
-      resolvedPathParts.push(foundCollection.dbPath);
-      remainingPath = removeInitialSlash(remainingPath.substring(matchString.length));
-      if (remainingPath.length === 0) {
-        foundMatch = true;
-        break;
-      }
-      const idSeparatorIndex = remainingPath.indexOf("/");
-      let entityId;
-      if (idSeparatorIndex > -1) {
-        entityId = remainingPath.substring(0, idSeparatorIndex);
-        remainingPath = remainingPath.substring(idSeparatorIndex + 1);
-      } else {
-        entityId = remainingPath;
-        remainingPath = "";
-        console.warn(`resolveCollectionPathIds: Path seems to end with an entity ID "${entityId}" instead of a collection segment in original path "${path}". This might indicate an invalid input path.`);
-      }
-      resolvedPathParts.push(entityId);
-      currentCollections = getSubcollections(foundCollection);
-      foundMatch = true;
-      if (!currentCollections && remainingPath.length > 0) {
-        console.warn(`resolveCollectionPathIds: Path continues after entity ID "${entityId}", but no subcollections are defined for the preceding collection "${foundCollection.slug}" in path "${path}". Appending remaining original path.`);
-        resolvedPathParts.push(remainingPath);
-        remainingPath = "";
-        break;
+  if (collection.childCollections) {
+    return collection.childCollections() ?? [];
+  }
+  if (getDataSourceCapabilities(collection.driver).supportsSubcollections && collection.subcollections) {
+    return collection.subcollections() ?? [];
+  }
+  if (getDataSourceCapabilities(collection.driver).supportsRelations && collection.relations) {
+    const manyRelations = collection.relations.filter((r) => r.cardinality === "many");
+    return manyRelations.map((r) => {
+      const target = r.target();
+      if (!target) return void 0;
+      const relationKey = r.relationName || target.slug;
+      let customName;
+      if (collection.properties) {
+        const prop = Object.entries(collection.properties).find(([_, p]) => p.type === "relation" && p.relationName === relationKey);
+        if (prop && prop[1].name) {
+          customName = prop[1].name;
+        }
       }
-    }
-    if (!foundMatch) {
-      console.warn(`resolveCollectionPathIds: Collection definition not found for segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
-      resolvedPathParts.push(remainingPath);
-      remainingPath = "";
-      break;
-    }
-  }
-  return resolvedPathParts.join("/");
-}
-function getCollectionBySlugWithin(slugOrPath, collections) {
-  const subpaths = removeInitialAndTrailingSlashes(slugOrPath).split("/");
-  if (subpaths.length % 2 === 0) {
-    throw Error(`getCollectionBySlug: Collection paths must have an odd number of segments: ${slugOrPath}`);
-  }
-  const subpathCombinations = getCollectionPathsCombinations(subpaths);
-  let result;
-  for (let i = 0; i < subpathCombinations.length; i++) {
-    const subpathCombination = subpathCombinations[i];
-    const navigationEntry = collections && collections.sort((a, b) => (a.slug ?? "").localeCompare(b.slug ?? "")).find((entry) => entry.slug === subpathCombination);
-    if (navigationEntry) {
-      if (subpathCombination === slugOrPath) {
-        result = navigationEntry;
-      } else if (navigationEntry.subcollections) {
-        const newPath = slugOrPath.replace(subpathCombination, "").split("/").slice(2).join("/");
-        if (newPath.length > 0) result = getCollectionBySlugWithin(newPath, getSubcollections(navigationEntry));
+      const baseOverrides = {
+        slug: relationKey
+      };
+      if (customName) {
+        baseOverrides.name = customName;
+        baseOverrides.singularName = customName;
       }
-    }
-    if (result) break;
-  }
-  return result;
-}
-function getCollectionPathsCombinations(subpaths) {
-  const entries = subpaths.length > 0 && subpaths.length % 2 === 0 ? subpaths.splice(0, subpaths.length - 1) : subpaths;
-  const length = entries.length;
-  const result = [];
-  for (let i = length; i > 0; i = i - 2) {
-    result.push(entries.slice(0, i).join("/"));
-  }
-  return result;
-}
-function navigateToEntity({
-  openEntityMode,
-  collection,
-  entityId,
-  copy,
-  path,
-  selectedTab,
-  sideEntityController,
-  onClose,
-  navigation
-}) {
-  if (openEntityMode === "side_panel") {
-    sideEntityController.open({
-      entityId,
-      path,
-      copy,
-      selectedTab,
-      collection,
-      updateUrl: true,
-      onClose
-    });
-  } else {
-    let to = navigation.buildUrlCollectionPath(entityId ? `${path ?? path}/${entityId}` : path ?? path);
-    if (entityId && selectedTab) {
-      to += `/${selectedTab}`;
-    }
-    if (!entityId) {
-      to += "#new";
-    }
-    if (copy) {
-      to += "#copy";
-    }
-    navigation.navigate(to);
-  }
-}
-const reservedKeys = ["edit", "copy", "delete"];
-function mergeEntityActions(currentActions, newActions) {
-  const updatedActions = [];
-  currentActions.forEach((action) => {
-    const newAction = newActions.find((a) => a.key === action.key);
-    if (newAction) {
-      const mergedAction = {
-        ...action,
-        ...newAction
+      const targetWithOverrides = {
+        ...target,
+        ...baseOverrides
       };
-      updatedActions.push(mergedAction);
-    } else {
-      updatedActions.push(action);
-    }
-  });
-  newActions.forEach((action) => {
-    if (!currentActions.find((a) => a.key === action.key) && (!action.key || !reservedKeys.includes(action.key))) {
-      updatedActions.push(action);
-    }
-  });
-  return updatedActions;
+      return r.overrides ? mergeDeep(targetWithOverrides, r.overrides) : targetWithOverrides;
+    }).filter((c) => Boolean(c));
+  }
+  return [];
 }
 function evaluateAST(sqlString, auth, entity) {
   if (!entity) return true;
@@ -1130,8 +635,8 @@ function evaluateAST(sqlString, auth, entity) {
     const userRoles = auth.user?.roles || [];
     return requiredRoles.every((r) => userRoles.includes(r));
   }
-  const pattern1 = new RegExp(`^\\{?([a-zA-Z0-9_]+)\\}?\\s*=\\s*(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))`);
-  const pattern2 = new RegExp(`^(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))\\s*=\\s*\\{?([a-zA-Z0-9_]+)\\}?`);
+  const pattern1 = new RegExp("^\\{?([a-zA-Z0-9_]+)\\}?\\s*=\\s*(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))");
+  const pattern2 = new RegExp("^(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))\\s*=\\s*\\{?([a-zA-Z0-9_]+)\\}?");
   const match1 = cleanedSQL.match(pattern1);
   if (match1 && match1[1]) {
     return entity.values[match1[1]] === auth.user?.uid;
@@ -1164,10 +669,11 @@ function evaluateRule(rule, auth, entity) {
   return true;
 }
 function checkOperation(collection, authController, entity, targetOperation) {
-  if (!collection.securityRules || collection.securityRules.length === 0) {
+  const securityRules = getDataSourceCapabilities(collection.driver).supportsRLS ? collection.securityRules : void 0;
+  if (!securityRules || securityRules.length === 0) {
     return true;
   }
-  const applicableRules = collection.securityRules.filter((r) => r.operation === targetOperation || r.operation === "all" || r.operations?.includes(targetOperation) || r.operations?.includes("all"));
+  const applicableRules = securityRules.filter((r) => r.operation === targetOperation || r.operation === "all" || r.operations?.includes(targetOperation) || r.operations?.includes("all"));
   if (applicableRules.length === 0) return false;
   const userRoleIds = authController.user?.roles ?? [];
   const userRoles = [...userRoleIds, "public"];
@@ -1204,127 +710,11 @@ function canEditEntity(collection, authController, path, entity) {
   return checkOperation(collection, authController, entity, "update");
 }
 function canCreateEntity(collection, authController, path, entity) {
-  if (collection.collectionGroup) return false;
   return checkOperation(collection, authController, entity, "insert");
 }
 function canDeleteEntity(collection, authController, path, entity) {
   return checkOperation(collection, authController, entity, "delete");
 }
-function plural(word, amount) {
-  if (amount !== void 0 && amount === 1) {
-    return word;
-  }
-  const plurals = {
-    "(quiz)$": "$1zes",
-    "^(ox)$": "$1en",
-    "([m|l])ouse$": "$1ice",
-    "(matr|vert|ind)ix|ex$": "$1ices",
-    "(x|ch|ss|sh)$": "$1es",
-    "([^aeiouy]|qu)y$": "$1ies",
-    "(hive)$": "$1s",
-    "(?:([^f])fe|([lr])f)$": "$1$2ves",
-    "(shea|lea|loa|thie)f$": "$1ves",
-    sis$: "ses",
-    "([ti])um$": "$1a",
-    "(tomat|potat|ech|her|vet)o$": "$1oes",
-    "(bu)s$": "$1ses",
-    "(alias)$": "$1es",
-    "(octop)us$": "$1i",
-    "(ax|test)is$": "$1es",
-    "(us)$": "$1es",
-    "([^s]+)$": "$1s"
-  };
-  const irregular = {
-    move: "moves",
-    foot: "feet",
-    goose: "geese",
-    sex: "sexes",
-    child: "children",
-    man: "men",
-    tooth: "teeth",
-    person: "people"
-  };
-  const uncountable = ["sheep", "fish", "deer", "moose", "series", "species", "money", "rice", "information", "equipment", "bison", "cod", "offspring", "pike", "salmon", "shrimp", "swine", "trout", "aircraft", "hovercraft", "spacecraft", "sugar", "tuna", "you", "wood"];
-  if (uncountable.indexOf(word.toLowerCase()) >= 0) {
-    return word;
-  }
-  for (const w in irregular) {
-    const pattern = new RegExp(`${w}$`, "i");
-    const replace = irregular[w];
-    if (pattern.test(word)) {
-      return word.replace(pattern, replace);
-    }
-  }
-  for (const reg in plurals) {
-    const pattern = new RegExp(reg, "i");
-    if (pattern.test(word)) {
-      return word.replace(pattern, plurals[reg]);
-    }
-  }
-  return word;
-}
-function singular(word, amount) {
-  if (amount !== void 0 && amount !== 1) {
-    return word;
-  }
-  const singulars = {
-    "(quiz)zes$": "$1",
-    "(matr)ices$": "$1ix",
-    "(vert|ind)ices$": "$1ex",
-    "^(ox)en$": "$1",
-    "(alias)es$": "$1",
-    "(octop|vir)i$": "$1us",
-    "(cris|ax|test)es$": "$1is",
-    "(shoe)s$": "$1",
-    "(o)es$": "$1",
-    "(bus)es$": "$1",
-    "([m|l])ice$": "$1ouse",
-    "(x|ch|ss|sh)es$": "$1",
-    "(m)ovies$": "$1ovie",
-    "(s)eries$": "$1eries",
-    "([^aeiouy]|qu)ies$": "$1y",
-    "([lr])ves$": "$1f",
-    "(tive)s$": "$1",
-    "(hive)s$": "$1",
-    "(li|wi|kni)ves$": "$1fe",
-    "(shea|loa|lea|thie)ves$": "$1f",
-    "(^analy)ses$": "$1sis",
-    "((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$": "$1$2sis",
-    "([ti])a$": "$1um",
-    "(n)ews$": "$1ews",
-    "(h|bl)ouses$": "$1ouse",
-    "(corpse)s$": "$1",
-    "(us)es$": "$1",
-    s$: ""
-  };
-  const irregular = {
-    move: "moves",
-    foot: "feet",
-    goose: "geese",
-    sex: "sexes",
-    child: "children",
-    man: "men",
-    tooth: "teeth",
-    person: "people"
-  };
-  const uncountable = ["sheep", "fish", "deer", "moose", "series", "species", "money", "rice", "information", "equipment", "bison", "cod", "offspring", "pike", "salmon", "shrimp", "swine", "trout", "aircraft", "hovercraft", "spacecraft", "sugar", "tuna", "you", "wood"];
-  if (uncountable.indexOf(word.toLowerCase()) >= 0) {
-    return word;
-  }
-  for (const w in irregular) {
-    const pattern = new RegExp(`${irregular[w]}$`, "i");
-    if (pattern.test(word)) {
-      return word.replace(pattern, w);
-    }
-  }
-  for (const reg in singulars) {
-    const pattern = new RegExp(reg, "i");
-    if (pattern.test(word)) {
-      return word.replace(pattern, singulars[reg]);
-    }
-  }
-  return word;
-}
 function getEntityImagePreviewPropertyKey(collection) {
   for (const key in collection.properties) {
     const property = collection.properties[key];
@@ -1346,46 +736,136 @@ function getEntityImagePreviewPropertyKey(collection) {
   }
   for (const key in collection.properties) {
     const property = collection.properties[key];
-    if (property.type === "array" && property.of?.type === "string" && property.of.url === "image") {
+    if (property.type === "array" && property.of && !Array.isArray(property.of) && property.of.type === "string" && property.of.url === "image") {
+      return key;
+    }
+  }
+  for (const key in collection.properties) {
+    const property = collection.properties[key];
+    if (property.type === "string" && property.storage && !property.storage.acceptedFiles) {
+      return key;
+    }
+  }
+  for (const key in collection.properties) {
+    const property = collection.properties[key];
+    if (property.type === "array" && !Array.isArray(property.of) && property.of?.type === "string" && property.of.storage && !property.of.storage.acceptedFiles) {
       return key;
     }
   }
   return void 0;
 }
-function flattenObject(obj, parentKey = "") {
-  if (!obj) return obj;
-  return Object.keys(obj).reduce((flatObj, key) => {
-    const newKey = parentKey ? `${parentKey}.${key}` : key;
-    if (typeof obj[key] === "object" && obj[key] !== null) {
-      if (Array.isArray(obj[key])) {
-        obj[key].forEach((item, index) => {
-          Object.assign(flatObj, flattenObject(item, `${newKey}[${index}]`));
-        });
+function removeInitialAndTrailingSlashes(s) {
+  return removeInitialSlash(removeTrailingSlash(s));
+}
+function removeInitialSlash(s) {
+  if (s.startsWith("/")) return s.slice(1);
+  else return s;
+}
+function removeTrailingSlash(s) {
+  if (s.endsWith("/")) return s.slice(0, -1);
+  else return s;
+}
+function addInitialSlash(s) {
+  if (s.startsWith("/")) return s;
+  else return `/${s}`;
+}
+function getLastSegment(path) {
+  const cleanPath = removeInitialAndTrailingSlashes(path);
+  if (cleanPath.includes("/")) {
+    const segments = cleanPath.split("/");
+    return segments[segments.length - 1];
+  }
+  return cleanPath;
+}
+function resolveCollectionPathIds(path, allCollections) {
+  let remainingPath = removeInitialAndTrailingSlashes(path);
+  if (!remainingPath) {
+    return "";
+  }
+  let currentCollections = allCollections;
+  const resolvedPathParts = [];
+  while (remainingPath.length > 0) {
+    if (!currentCollections || currentCollections.length === 0) {
+      console.warn(`resolveCollectionPathIds: Path structure implies subcollections, but none found before segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
+      resolvedPathParts.push(remainingPath);
+      remainingPath = "";
+      break;
+    }
+    let foundMatch = false;
+    const potentialMatches = currentCollections.flatMap((col) => [{
+      col,
+      match: col.slug
+    }]).filter((p) => p.match && remainingPath.startsWith(p.match)).sort((a, b) => b.match.length - a.match.length);
+    if (potentialMatches.length > 0) {
+      const {
+        col: foundCollection,
+        match: matchString
+      } = potentialMatches[0];
+      resolvedPathParts.push(foundCollection.slug);
+      remainingPath = removeInitialSlash(remainingPath.substring(matchString.length));
+      if (remainingPath.length === 0) {
+        foundMatch = true;
+        break;
+      }
+      const idSeparatorIndex = remainingPath.indexOf("/");
+      let entityId;
+      if (idSeparatorIndex > -1) {
+        entityId = remainingPath.substring(0, idSeparatorIndex);
+        remainingPath = remainingPath.substring(idSeparatorIndex + 1);
       } else {
-        Object.assign(flatObj, flattenObject(obj[key], newKey));
+        entityId = remainingPath;
+        remainingPath = "";
+        console.warn(`resolveCollectionPathIds: Path seems to end with an entity ID "${entityId}" instead of a collection segment in original path "${path}". This might indicate an invalid input path.`);
+      }
+      resolvedPathParts.push(entityId);
+      currentCollections = getSubcollections(foundCollection);
+      foundMatch = true;
+      if (!currentCollections && remainingPath.length > 0) {
+        console.warn(`resolveCollectionPathIds: Path continues after entity ID "${entityId}", but no subcollections are defined for the preceding collection "${foundCollection.slug}" in path "${path}". Appending remaining original path.`);
+        resolvedPathParts.push(remainingPath);
+        remainingPath = "";
+        break;
       }
-    } else {
-      flatObj[newKey] = obj[key];
     }
-    return flatObj;
-  }, {});
+    if (!foundMatch) {
+      console.warn(`resolveCollectionPathIds: Collection definition not found for segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
+      resolvedPathParts.push(remainingPath);
+      remainingPath = "";
+      break;
+    }
+  }
+  return resolvedPathParts.join("/");
 }
-function getArrayValuesCount(array) {
-  return array.reduce((acc, obj) => {
-    Object.entries(obj).forEach(([key, value]) => {
-      if (Array.isArray(value)) {
-        acc[key] = Math.max(acc[key] || 0, value.length);
-      }
-      if (typeof value === "object" && value !== null) {
-        const nested = getArrayValuesCount([value]);
-        Object.entries(nested).forEach(([nestedKey, nestedCount]) => {
-          const compoundKey = `${key}.${nestedKey}`;
-          acc[compoundKey] = Math.max(acc[compoundKey] || 0, nestedCount);
-        });
+function getCollectionBySlugWithin(slugOrPath, collections) {
+  const subpaths = removeInitialAndTrailingSlashes(slugOrPath).split("/");
+  if (subpaths.length % 2 === 0) {
+    throw Error(`getCollectionBySlug: Collection paths must have an odd number of segments: ${slugOrPath}`);
+  }
+  const subpathCombinations = getCollectionPathsCombinations(subpaths);
+  let result;
+  for (let i = 0; i < subpathCombinations.length; i++) {
+    const subpathCombination = subpathCombinations[i];
+    const navigationEntry = collections && collections.sort((a, b) => (a.slug ?? "").localeCompare(b.slug ?? "")).find((entry) => entry.slug === subpathCombination);
+    if (navigationEntry) {
+      if (subpathCombination === slugOrPath) {
+        result = navigationEntry;
+      } else if (getSubcollections(navigationEntry).length > 0) {
+        const newPath = slugOrPath.replace(subpathCombination, "").split("/").slice(2).join("/");
+        if (newPath.length > 0) result = getCollectionBySlugWithin(newPath, getSubcollections(navigationEntry));
       }
-    });
-    return acc;
-  }, {});
+    }
+    if (result) break;
+  }
+  return result;
+}
+function getCollectionPathsCombinations(subpaths) {
+  const entries = subpaths.length > 0 && subpaths.length % 2 === 0 ? subpaths.splice(0, subpaths.length - 1) : subpaths;
+  const length = entries.length;
+  const result = [];
+  for (let i = length; i > 0; i = i - 2) {
+    result.push(entries.slice(0, i).join("/"));
+  }
+  return result;
 }
 function getNavigationEntriesFromPath(props) {
   const {
@@ -1426,7 +906,7 @@ function getNavigationEntriesFromPath(props) {
             throw Error("collection not found resolving path: " + collection);
           }
           const entityViews = collection.entityViews;
-          const customView = entityViews && entityViews.map((entry) => resolveEntityView(entry, props.contextEntityViews)).filter(Boolean).find((entry) => entry.key === newPath);
+          const customView = entityViews && entityViews.map((entry) => resolveEntityView(entry, props.contextEntityViews)).filter((v) => v != null).find((entry) => entry.key === newPath);
           const subcollections = getSubcollections(collection);
           if (customView) {
             result.push({
@@ -1486,7 +966,7 @@ function getParentReferencesFromPath(props) {
           if (!collection) {
             throw Error("collection not found resolving path: " + collection);
           }
-          if (collection.subcollections) {
+          if (getSubcollections(collection).length > 0) {
             result.push(...getParentReferencesFromPath({
               path: newPath,
               collections: getSubcollections(collection),
@@ -1524,9 +1004,6 @@ function buildEntityCallbacks(callbacks) {
 function buildAdditionalFieldDelegate(additionalFieldDelegate) {
   return additionalFieldDelegate;
 }
-function buildFieldConfig(propertyConfig) {
-  return propertyConfig;
-}
 async function resolveStorageFilenameString({
   input,
   storage,
@@ -1618,9 +1095,6 @@ function replacePlaceholders({
   if (!result) result = randomString() + "_" + file.name;
   return result;
 }
-function toArray(input) {
-  return Array.isArray(input) ? input : input ? [input] : [];
-}
 function hasPropertyCallbacks(properties, callbackName) {
   if (!properties) return false;
   for (const property of Object.values(properties)) {
@@ -1639,13 +1113,13 @@ function hasPropertyCallbacks(properties, callbackName) {
 }
 async function processProperties(properties, values, previousValues, propsContext, callbackName) {
   if (!values || typeof values !== "object") return values;
-  let result = {
+  const result = {
     ...values
   };
   for (const [key, property] of Object.entries(properties)) {
     if (result[key] === void 0) continue;
     let currentValue = result[key];
-    let previousValue = previousValues?.[key];
+    const previousValue = previousValues?.[key];
     if (property.type === "array" && Array.isArray(currentValue)) {
       if (property.of && !Array.isArray(property.of)) {
         currentValue = await Promise.all(currentValue.map(async (item, index) => {
@@ -1697,22 +1171,6 @@ const buildPropertyCallbacks = (properties) => {
   }
   return Object.keys(propertyCallbacks).length > 0 ? propertyCallbacks : void 0;
 };
-function hashString(str) {
-  let hash2 = 0;
-  let i;
-  let chr;
-  for (i = 0; i < str.length; i++) {
-    chr = str.charCodeAt(i);
-    hash2 = (hash2 << 5) - hash2 + chr;
-    hash2 |= 0;
-  }
-  return Math.abs(hash2);
-}
-function generateForeignKeyName(name) {
-  const snakeCaseName = toSnakeCase(name);
-  const singularName = snakeCaseName.endsWith("s") ? snakeCaseName.slice(0, -1) : snakeCaseName;
-  return `${singularName}_id`;
-}
 function sanitizeRelation(relation, sourceCollection) {
   if (!relation.target) {
     throw new Error("Relation is missing a `target` collection.");
@@ -1722,7 +1180,7 @@ function sanitizeRelation(relation, sourceCollection) {
     ...relation
   };
   if (!newRelation.relationName) {
-    newRelation.relationName = toSnakeCase(targetCollection.slug ?? targetCollection.dbPath);
+    newRelation.relationName = toSnakeCase(targetCollection.slug);
   }
   if (!newRelation.direction) {
     if (newRelation.foreignKeyOnTarget) newRelation.direction = "inverse";
@@ -1740,12 +1198,12 @@ function sanitizeRelation(relation, sourceCollection) {
       if (!newRelation.foreignKeyOnTarget) {
         let foundForeignKey = false;
         try {
-          const targetRelations = targetCollection.relations || [];
+          const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? targetCollection.relations || [] : [];
           for (const targetRel of targetRelations) {
             if (targetRel.direction === "owning" && targetRel.cardinality === "one" && targetRel.localKey) {
               try {
                 const targetRelTarget = targetRel.target();
-                if (targetRelTarget.slug === sourceCollection.slug || targetRelTarget.dbPath === sourceCollection.dbPath) {
+                if (targetRelTarget.slug === sourceCollection.slug) {
                   newRelation.foreignKeyOnTarget = targetRel.localKey;
                   foundForeignKey = true;
                   break;
@@ -1766,9 +1224,9 @@ function sanitizeRelation(relation, sourceCollection) {
       let isManyToManyInverse = false;
       if (newRelation.inverseRelationName && !newRelation.foreignKeyOnTarget) {
         try {
-          const targetRelations = targetCollection.relations || [];
+          const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? targetCollection.relations || [] : [];
           for (const targetRel of targetRelations) {
-            if (targetRel.cardinality === "many" && targetRel.direction === "owning" && targetRel.through && targetRel.relationName === newRelation.inverseRelationName) {
+            if (targetRel.cardinality === "many" && (targetRel.direction === "owning" || !targetRel.direction) && targetRel.relationName === newRelation.inverseRelationName) {
               isManyToManyInverse = true;
               break;
             }
@@ -1795,19 +1253,26 @@ function sanitizeRelation(relation, sourceCollection) {
   if (newRelation.cardinality === "one" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath) {
     throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'inverse' one-to-one relation requires a 'foreignKeyOnTarget'. Check the relation config for '${newRelation.relationName}'`);
   }
-  if (newRelation.cardinality === "many" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath) {
+  if (newRelation.cardinality === "many" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath && !newRelation.inverseRelationName) {
     throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'inverse' one-to-many relation requires a 'foreignKeyOnTarget'. Check the relation config for '${newRelation.relationName}'`);
   }
   return newRelation;
 }
+const _resolvedRelationsCache = /* @__PURE__ */ new WeakMap();
 function resolveCollectionRelations(collection) {
+  const cached = _resolvedRelationsCache.get(collection);
+  if (cached) return cached;
+  if (!getDataSourceCapabilities(collection.driver).supportsRelations) return {};
+  const relCollection = collection;
   const relations = {};
-  if (collection.relations) {
-    collection.relations.forEach((relation) => {
+  const registeredRelationNames = /* @__PURE__ */ new Set();
+  if (relCollection.relations) {
+    relCollection.relations.forEach((relation) => {
       const normalizedRelation = sanitizeRelation(relation, collection);
       const relationKey = normalizedRelation.relationName;
       if (relationKey) {
         relations[relationKey] = normalizedRelation;
+        registeredRelationNames.add(relationKey);
       }
     });
   }
@@ -1819,15 +1284,17 @@ function resolveCollectionRelations(collection) {
         sourceCollection: collection
       });
       if (relation) {
-        if (!relations[propKey]) {
-          if (!relation.relationName) {
-            relation.relationName = propKey;
-          }
-          relations[propKey] = sanitizeRelation(relation, collection);
+        if (relations[propKey]) return;
+        if (!relation.relationName) {
+          relation.relationName = propKey;
         }
+        const normalizedRelation = sanitizeRelation(relation, collection);
+        relations[propKey] = normalizedRelation;
+        registeredRelationNames.add(normalizedRelation.relationName ?? propKey);
       }
     });
   }
+  _resolvedRelationsCache.set(collection, relations);
   return relations;
 }
 function resolvePropertyRelation({
@@ -1836,15 +1303,35 @@ function resolvePropertyRelation({
   sourceCollection
 }) {
   if (property.type !== "relation") return void 0;
-  const relation = sourceCollection.relations?.find((rel) => rel.relationName === property.relationName);
+  const relProp = property;
+  if (relProp.target) {
+    return {
+      relationName: relProp.relationName || propertyKey,
+      target: relProp.target,
+      cardinality: relProp.cardinality || "one",
+      direction: relProp.direction || "owning",
+      inverseRelationName: relProp.inverseRelationName,
+      localKey: relProp.localKey,
+      foreignKeyOnTarget: relProp.foreignKeyOnTarget,
+      through: relProp.through,
+      joinPath: relProp.joinPath,
+      onUpdate: relProp.onUpdate,
+      onDelete: relProp.onDelete,
+      overrides: relProp.overrides
+    };
+  }
+  const relation = (sourceCollection.relations ?? []).find((rel) => rel.relationName === relProp.relationName);
   if (!relation) {
-    console.warn(`Unrecognized relation format for property '${propertyKey}' in collection '${sourceCollection.slug || sourceCollection.dbPath}'`);
+    console.warn(`Unrecognized relation format for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
     return void 0;
   }
   return relation;
 }
 function getTableName(collection) {
-  return collection.dbPath ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
+  if (getDataSourceCapabilities(collection.driver).supportsRelations) {
+    return collection.table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
+  }
+  return toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
 }
 function getTableVarName(tableName) {
   return tableName.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
@@ -1857,6 +1344,14 @@ function getEnumVarName(tableName, propName) {
 function getColumnName(fullColumn) {
   return fullColumn.includes(".") ? fullColumn.split(".").pop() : fullColumn;
 }
+function findRelation(resolvedRelations, key) {
+  if (resolvedRelations[key]) return resolvedRelations[key];
+  const slugKey = key.replace(/_/g, "-");
+  if (slugKey !== key && resolvedRelations[slugKey]) return resolvedRelations[slugKey];
+  const snakeKey = key.replace(/-/g, "_");
+  if (snakeKey !== key && resolvedRelations[snakeKey]) return resolvedRelations[snakeKey];
+  return void 0;
+}
 function getIn(obj, path) {
   if (!obj || !path) return void 0;
   return path.split(".").reduce((acc, part) => acc && acc[part], obj);
@@ -1942,7 +1437,7 @@ function buildConditionContext(params) {
       email: user?.email ?? null,
       displayName: user?.displayName ?? null,
       photoURL: user?.photoURL ?? null,
-      roles: user?.roles ?? []
+      roles: (user?.roles ?? []).map((r) => typeof r === "string" ? r : r.id)
     },
     now: Date.now()
   };
@@ -1952,7 +1447,7 @@ function applyPropertyConditions(property, context) {
     conditions
   } = property;
   if (!conditions) return property;
-  let result = {
+  const result = {
     ...property
   };
   if (conditions.disabled) {
@@ -1992,8 +1487,8 @@ function applyPropertyConditions(property, context) {
   if (context.isNew && conditions.defaultValue !== void 0) {
     result.defaultValue = evaluateCondition(conditions.defaultValue, context);
   }
-  if ("enumValues" in result && result.enumValues && (conditions.enumConditions || conditions.allowedEnumValues || conditions.excludedEnumValues)) {
-    result.enumValues = applyEnumConditions(result.enumValues, conditions, context);
+  if ("enum" in result && result.enum && (conditions.enumConditions || conditions.allowedEnumValues || conditions.excludedEnumValues)) {
+    result.enum = applyEnumConditions(result.enum, conditions, context);
   }
   if (result.type === "reference") {
     if (conditions.referencePath) {
@@ -2059,13 +1554,15 @@ function applyEnumConditions(enumValues, conditions, context) {
 }
 class CollectionRegistry {
   // Normalized runtime layer (used by Data Grid / UI)
-  collectionsByDbPath = /* @__PURE__ */ new Map();
+  collectionsByTableName = /* @__PURE__ */ new Map();
   collectionsBySlug = /* @__PURE__ */ new Map();
   rootCollections = [];
+  cachedCollectionsList = null;
   // Raw configuration layer (used by Collection Editor AST generator)
-  rawCollectionsByDbPath = /* @__PURE__ */ new Map();
+  rawCollectionsByTableName = /* @__PURE__ */ new Map();
   rawCollectionsBySlug = /* @__PURE__ */ new Map();
   rawRootCollections = [];
+  cachedRawCollectionsList = null;
   // Snapshot of raw input for idempotency check — compared BEFORE normalization
   // to avoid the issue where normalization creates new objects that always fail equality.
   lastRawInputSnapshot = null;
@@ -2075,12 +1572,14 @@ class CollectionRegistry {
     }
   }
   reset() {
-    this.collectionsByDbPath.clear();
+    this.collectionsByTableName.clear();
     this.collectionsBySlug.clear();
     this.rootCollections = [];
-    this.rawCollectionsByDbPath.clear();
+    this.cachedCollectionsList = null;
+    this.rawCollectionsByTableName.clear();
     this.rawCollectionsBySlug.clear();
     this.rawRootCollections = [];
+    this.cachedRawCollectionsList = null;
   }
   /**
    * Registers a collection and its subcollections recursively.
@@ -2099,7 +1598,31 @@ class CollectionRegistry {
     const normalizedCollections = collections.map((c) => this.normalizeCollection({
       ...c
     }));
-    normalizedCollections.forEach((c, index) => this.register(c, collections[index]));
+    normalizedCollections.forEach((c, index) => {
+      const raw = cloneDeep(collections[index]);
+      this.rootCollections.push(c);
+      this.rawRootCollections.push(raw);
+      const normalized = this.normalizeCollection(c);
+      this.collectionsByTableName.set(getTableName(normalized), normalized);
+      this.rawCollectionsByTableName.set(getTableName(raw), raw);
+      if (normalized.slug) {
+        this.collectionsBySlug.set(normalized.slug, normalized);
+      }
+      if (raw.slug) {
+        this.rawCollectionsBySlug.set(raw.slug, raw);
+      }
+    });
+    normalizedCollections.forEach((c) => {
+      const subcollections = getSubcollections(c);
+      if (subcollections && subcollections.length > 0) {
+        subcollections.forEach((subCollection) => {
+          if (!subCollection) return;
+          this._registerRecursively(this.normalizeCollection({
+            ...subCollection
+          }), cloneDeep(subCollection));
+        });
+      }
+    });
     this.lastRawInputSnapshot = rawSnapshot;
     return true;
   }
@@ -2110,49 +1633,127 @@ class CollectionRegistry {
     this._registerRecursively(collection, raw);
   }
   _registerRecursively(collection, rawCollection) {
-    if (this.collectionsByDbPath.has(collection.dbPath)) {
+    if (this.collectionsByTableName.has(getTableName(collection))) {
       return;
     }
     const normalizedCollection = this.normalizeCollection(collection);
-    this.collectionsByDbPath.set(normalizedCollection.dbPath, normalizedCollection);
-    this.rawCollectionsByDbPath.set(rawCollection.dbPath, rawCollection);
+    this.collectionsByTableName.set(getTableName(normalizedCollection), normalizedCollection);
+    this.rawCollectionsByTableName.set(getTableName(rawCollection), rawCollection);
     if (normalizedCollection.slug) {
       this.collectionsBySlug.set(normalizedCollection.slug, normalizedCollection);
     }
     if (rawCollection.slug) {
       this.rawCollectionsBySlug.set(rawCollection.slug, rawCollection);
     }
-    const subcollections = getSubcollections(collection);
-    const rawSubcollections = getSubcollections(rawCollection);
-    if (subcollections && rawSubcollections) {
-      subcollections.forEach((subCollection, index) => {
-        this._registerRecursively(this.normalizeCollection(subCollection), cloneDeep(rawSubcollections[index]));
+    const subcollections = getSubcollections(normalizedCollection);
+    if (subcollections && subcollections.length > 0) {
+      subcollections.forEach((subCollection) => {
+        if (!subCollection) return;
+        this._registerRecursively(this.normalizeCollection({
+          ...subCollection
+        }), cloneDeep(subCollection));
       });
     }
   }
   normalizeCollection(collection) {
-    const properties = this.normalizeProperties(collection.properties, collection.relations ?? []);
-    collection.properties = properties;
-    return collection;
+    const result = {
+      ...collection
+    };
+    const extractedRelations = this.extractRelationsFromProperties(result.properties);
+    const relResult = result;
+    const manualRelations = getDataSourceCapabilities(result.driver).supportsRelations ? relResult.relations ?? [] : [];
+    const mergedRelationsRaw = [...extractedRelations];
+    for (const manual of manualRelations) {
+      const name = manual.relationName;
+      if (!name || !mergedRelationsRaw.find((r) => r.relationName === name)) {
+        mergedRelationsRaw.push(manual);
+      }
+    }
+    let mergedRelations = mergedRelationsRaw;
+    if (getDataSourceCapabilities(result.driver).supportsRelations) {
+      mergedRelations = mergedRelationsRaw.map((r) => {
+        try {
+          return sanitizeRelation(r, result);
+        } catch {
+          return r;
+        }
+      });
+      relResult.relations = mergedRelations;
+    }
+    const properties = this.normalizeProperties(result.properties, mergedRelations);
+    result.properties = properties;
+    if (!result.childCollections) {
+      if (getDataSourceCapabilities(result.driver).supportsSubcollections && result.subcollections) {
+        result.childCollections = result.subcollections;
+      } else if (getDataSourceCapabilities(result.driver).supportsRelations && relResult.relations) {
+        const manyRelations = relResult.relations.filter((r) => r.cardinality === "many");
+        if (manyRelations.length > 0) {
+          result.childCollections = () => manyRelations.map((r) => {
+            const target = r.target();
+            return r.overrides ? mergeDeep(target, r.overrides) : target;
+          });
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Extract Relation[] from properties that have inline relation config (i.e. `target` is set).
+   * This allows developers to define relations directly on properties without a separate
+   * `relations[]` entry on the collection.
+   */
+  extractRelationsFromProperties(properties) {
+    const relations = [];
+    for (const [key, property] of Object.entries(properties)) {
+      if (property.type === "relation") {
+        const relProp = property;
+        const target = relProp.target ?? relProp.relation?.target;
+        if (target) {
+          const relationName = relProp.relationName ?? relProp.relation?.relationName ?? key;
+          relations.push({
+            relationName,
+            target,
+            cardinality: relProp.cardinality ?? relProp.relation?.cardinality ?? "one",
+            direction: relProp.direction ?? relProp.relation?.direction ?? "owning",
+            inverseRelationName: relProp.inverseRelationName ?? relProp.relation?.inverseRelationName,
+            localKey: relProp.localKey ?? relProp.relation?.localKey,
+            foreignKeyOnTarget: relProp.foreignKeyOnTarget ?? relProp.relation?.foreignKeyOnTarget,
+            through: relProp.through ?? relProp.relation?.through,
+            joinPath: relProp.joinPath ?? relProp.relation?.joinPath,
+            onUpdate: relProp.onUpdate ?? relProp.relation?.onUpdate,
+            onDelete: relProp.onDelete ?? relProp.relation?.onDelete,
+            overrides: relProp.overrides ?? relProp.relation?.overrides
+          });
+        }
+      } else if (property.type === "map" && property.properties) {
+        relations.push(...this.extractRelationsFromProperties(property.properties));
+      }
+    }
+    return relations;
   }
   normalizeProperties(properties, relations) {
     const newProperties = {};
     for (const key in properties) {
-      newProperties[key] = this.normalizeProperty(properties[key], relations);
+      newProperties[key] = this.normalizeProperty(key, properties[key], relations);
     }
     return newProperties;
   }
-  normalizeProperty(property, relations) {
+  normalizeProperty(key, property, relations) {
     const newProperty = {
       ...property
     };
     if (newProperty.type === "map" && newProperty.properties) {
       newProperty.properties = this.normalizeProperties(newProperty.properties, relations);
     } else if (newProperty.type === "array") {
-      if (newProperty.of) {
-        newProperty.of = this.normalizeProperty(newProperty.of, relations);
-      } else if (newProperty.oneOf && newProperty.oneOf.properties) {
-        newProperty.oneOf.properties = this.normalizeProperties(newProperty.oneOf.properties, relations);
+      const arrayProp = newProperty;
+      if (arrayProp.of) {
+        if (Array.isArray(arrayProp.of)) {
+          arrayProp.of = arrayProp.of.map((p, i) => this.normalizeProperty(`${key}[${i}]`, p, relations));
+        } else {
+          arrayProp.of = this.normalizeProperty(`${key}.of`, arrayProp.of, relations);
+        }
+      } else if (arrayProp.oneOf && arrayProp.oneOf.properties) {
+        arrayProp.oneOf.properties = this.normalizeProperties(arrayProp.oneOf.properties, relations);
       }
     } else if ((newProperty.type === "string" || newProperty.type === "number") && newProperty.enum) {
       const stringOrNumberProperty = newProperty;
@@ -2161,11 +1762,12 @@ class CollectionRegistry {
       }
     } else if (newProperty.type === "relation") {
       const relationProperty = newProperty;
-      const relation = relations.find((r) => r.relationName === relationProperty.relationName);
+      const name = relationProperty.relationName || key;
+      const relation = relations.find((r) => r.relationName === name);
       if (relation) {
         relationProperty.relation = relation;
       } else {
-        console.warn(`Could not find relation for property with relationName: ${relationProperty.relationName}`);
+        console.warn(`Could not find relation for property '${key}' with relationName: ${name}`);
       }
     }
     return newProperty;
@@ -2173,7 +1775,12 @@ class CollectionRegistry {
   get(path) {
     const bySlug = this.collectionsBySlug.get(path);
     if (bySlug) return bySlug;
-    return this.collectionsByDbPath.get(path);
+    if (path.includes("-")) {
+      const normalized = path.replace(/-/g, "_");
+      const byNormalized = this.collectionsBySlug.get(normalized);
+      if (byNormalized) return byNormalized;
+    }
+    return this.collectionsByTableName.get(path);
   }
   /**
    * Gets the pristine, un-normalized collection exactly as it was provided.
@@ -2182,7 +1789,12 @@ class CollectionRegistry {
   getRaw(path) {
     const bySlug = this.rawCollectionsBySlug.get(path);
     if (bySlug) return bySlug;
-    return this.rawCollectionsByDbPath.get(path);
+    if (path.includes("-")) {
+      const normalized = path.replace(/-/g, "_");
+      const byNormalized = this.rawCollectionsBySlug.get(normalized);
+      if (byNormalized) return byNormalized;
+    }
+    return this.rawCollectionsByTableName.get(path);
   }
   /**
    * Get collection by resolving multi-segment paths through relations
@@ -2203,10 +1815,13 @@ class CollectionRegistry {
     }
     for (let i = 2; i < pathSegments.length; i += 2) {
       const relationKey = pathSegments[i];
+      if (!getDataSourceCapabilities(currentCollection.driver).supportsRelations) {
+        throw new Error(`Relation path navigation requires a collection that supports relations, but '${currentCollection.slug}' uses driver '${currentCollection.driver}'`);
+      }
       const resolvedRelations = resolveCollectionRelations(currentCollection);
-      const relation = resolvedRelations[relationKey];
+      const relation = findRelation(resolvedRelations, relationKey);
       if (!relation) {
-        throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug || currentCollection.dbPath}'`);
+        throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'`);
       }
       currentCollection = relation.target();
       if (i + 1 < pathSegments.length) ;
@@ -2214,10 +1829,16 @@ class CollectionRegistry {
     return currentCollection;
   }
   getCollections() {
-    return Array.from(this.collectionsByDbPath.values());
+    if (!this.cachedCollectionsList) {
+      this.cachedCollectionsList = Array.from(this.collectionsByTableName.values());
+    }
+    return this.cachedCollectionsList;
   }
   getRawCollections() {
-    return Array.from(this.rawCollectionsByDbPath.values());
+    if (!this.cachedRawCollectionsList) {
+      this.cachedRawCollectionsList = Array.from(this.rawCollectionsByTableName.values());
+    }
+    return this.cachedRawCollectionsList;
   }
   /**
    * Resolves a multi-segment path like "products/123/locales" and returns
@@ -2243,13 +1864,13 @@ class CollectionRegistry {
       entityIds.push(entityId);
       if (i + 1 < pathSegments.length) {
         const subcollectionSlug = pathSegments[i + 1];
-        const subcollections = currentCollection.subcollections?.();
-        if (!subcollections) {
-          throw new Error(`No subcollections found for ${currentCollection.slug || currentCollection.dbPath} in path: ${path}`);
+        const subcollections = getSubcollections(currentCollection);
+        if (!subcollections || subcollections.length === 0) {
+          throw new Error(`No subcollections found for ${currentCollection.slug} in path: ${path}`);
         }
         const subcollection = subcollections.find((c) => c.slug === subcollectionSlug);
         if (!subcollection) {
-          throw new Error(`Subcollection '${subcollectionSlug}' not found in ${currentCollection.slug || currentCollection.dbPath}`);
+          throw new Error(`Subcollection '${subcollectionSlug}' not found in ${currentCollection.slug}`);
         }
         currentCollection = subcollection;
         collections.push(currentCollection);
@@ -2262,6 +1883,205 @@ class CollectionRegistry {
     };
   }
 }
+function convertWhereToFilter(where) {
+  if (!where) return void 0;
+  const operatorMap = {
+    "eq": "==",
+    "neq": "!=",
+    "gt": ">",
+    "gte": ">=",
+    "lt": "<",
+    "lte": "<=",
+    "in": "in",
+    "nin": "not-in",
+    "not-in": "not-in",
+    "cs": "array-contains",
+    "csa": "array-contains-any",
+    "==": "==",
+    "!=": "!=",
+    ">": ">",
+    ">=": ">=",
+    "<": "<",
+    "<=": "<=",
+    "array-contains": "array-contains",
+    "array-contains-any": "array-contains-any"
+  };
+  const filter = {};
+  for (const [field, rawValue] of Object.entries(where)) {
+    if (rawValue === null) {
+      filter[field] = ["==", null];
+      continue;
+    }
+    if (typeof rawValue === "boolean") {
+      filter[field] = ["==", rawValue];
+      continue;
+    }
+    if (typeof rawValue === "number") {
+      filter[field] = ["==", rawValue];
+      continue;
+    }
+    if (Array.isArray(rawValue) && rawValue.length === 2) {
+      const [rawOp, val] = rawValue;
+      const mappedOp = operatorMap[rawOp] ?? "==";
+      filter[field] = [mappedOp, val];
+      continue;
+    }
+    if (typeof rawValue === "string") {
+      const dotIndex = rawValue.indexOf(".");
+      if (dotIndex === -1) {
+        filter[field] = ["==", rawValue];
+        continue;
+      }
+      const op = rawValue.substring(0, dotIndex);
+      let value = rawValue.substring(dotIndex + 1);
+      if (typeof value === "string" && value.startsWith("(") && value.endsWith(")")) {
+        value = value.slice(1, -1).split(",").map((v) => v.trim());
+      }
+      if (value === "null") {
+        value = null;
+      } else if (value === "true") {
+        value = true;
+      } else if (value === "false") {
+        value = false;
+      } else if (typeof value === "string" && !isNaN(Number(value)) && value.trim() !== "") {
+        value = Number(value);
+      }
+      const mappedOp = operatorMap[op];
+      if (mappedOp) {
+        filter[field] = [mappedOp, value];
+      }
+    }
+  }
+  return Object.keys(filter).length > 0 ? filter : void 0;
+}
+function parseOrderBy(orderBy) {
+  if (!orderBy) return void 0;
+  const parts = orderBy.split(":");
+  const field = parts[0];
+  const direction = parts[1] || "asc";
+  return [field, direction];
+}
+function createDriverAccessor(driver, slug) {
+  return {
+    async find(params) {
+      const orderParsed = parseOrderBy(params?.orderBy);
+      const entities = await driver.fetchCollection({
+        path: slug,
+        limit: params?.limit,
+        offset: params?.offset,
+        filter: convertWhereToFilter(params?.where),
+        orderBy: orderParsed?.[0],
+        order: orderParsed?.[1],
+        searchString: params?.searchString
+      });
+      const limit = params?.limit ?? 20;
+      const offset = params?.offset ?? 0;
+      return {
+        data: entities,
+        meta: {
+          total: entities.length,
+          limit,
+          offset,
+          hasMore: entities.length >= limit
+        }
+      };
+    },
+    async findById(id) {
+      return driver.fetchEntity({
+        path: slug,
+        entityId: id
+      });
+    },
+    async create(data, id) {
+      return driver.saveEntity({
+        path: slug,
+        values: data,
+        entityId: id,
+        status: "new"
+      });
+    },
+    async update(id, data) {
+      return driver.saveEntity({
+        path: slug,
+        values: data,
+        entityId: id,
+        status: "existing"
+      });
+    },
+    async delete(id) {
+      return driver.deleteEntity({
+        entity: {
+          id,
+          path: slug,
+          values: {}
+        }
+      });
+    },
+    count: driver.countEntities ? async (params) => {
+      return driver.countEntities({
+        path: slug,
+        filter: convertWhereToFilter(params?.where)
+      });
+    } : void 0,
+    listen: driver.listenCollection ? (params, onUpdate, onError) => {
+      const orderParsed = parseOrderBy(params?.orderBy);
+      const limit = params?.limit ?? 20;
+      const offset = params?.offset ?? 0;
+      return driver.listenCollection({
+        path: slug,
+        limit: params?.limit,
+        offset: params?.offset,
+        filter: convertWhereToFilter(params?.where),
+        orderBy: orderParsed?.[0],
+        order: orderParsed?.[1],
+        searchString: params?.searchString,
+        onUpdate: (entities) => {
+          onUpdate({
+            data: entities,
+            meta: {
+              total: entities.length,
+              limit,
+              offset,
+              hasMore: entities.length >= limit
+            }
+          });
+        },
+        onError
+      });
+    } : void 0,
+    listenById: driver.listenEntity ? (id, onUpdate, onError) => {
+      return driver.listenEntity({
+        path: slug,
+        entityId: id,
+        onUpdate: (entity) => onUpdate(entity ?? void 0),
+        onError
+      });
+    } : void 0
+  };
+}
+function buildRebaseData(driver) {
+  const cache = /* @__PURE__ */ new Map();
+  function getAccessor(slug) {
+    let accessor = cache.get(slug);
+    if (!accessor) {
+      accessor = createDriverAccessor(driver, slug);
+      cache.set(slug, accessor);
+    }
+    return accessor;
+  }
+  const target = {
+    collection: getAccessor
+  };
+  return new Proxy(target, {
+    get(_target, prop) {
+      if (prop === "collection") return getAccessor;
+      if (typeof prop === "symbol") return void 0;
+      if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return void 0;
+      const slug = toSnakeCase(prop);
+      return getAccessor(slug);
+    }
+  });
+}
 export {
   COLLECTION_PATH_SEPARATOR,
   CollectionRegistry,
@@ -2275,23 +2095,22 @@ export {
   buildEntityCallbacks,
   buildEnum,
   buildEnumValueConfig,
-  buildFieldConfig,
   buildProperties,
   buildPropertiesOrBuilder,
   buildProperty,
   buildPropertyCallbacks,
+  buildRebaseData,
   canCreateEntity,
   canDeleteEntity,
   canEditEntity,
   canReadCollection,
-  clone,
-  defaultDateFormat,
+  createRelationRef,
+  createRelationRefWithData,
   enumToObjectEntries,
   evaluateCondition,
-  flattenObject,
+  findRelation,
   fullPathToCollectionSegments,
   getArrayResolvedProperties,
-  getArrayValuesCount,
   getCollectionBySlugWithin,
   getCollectionPathsCombinations,
   getColumnName,
@@ -2300,8 +2119,6 @@ export {
   getDefaultValuesFor,
   getEntityImagePreviewPropertyKey,
   getEnumVarName,
-  getHashValue,
-  getIn$1 as getIn,
   getLabelOrConfigFrom,
   getLastSegment,
   getLocalChangesBackup,
@@ -2313,44 +2130,18 @@ export {
   getSubcollections,
   getTableName,
   getTableVarName,
-  getValueInPath,
-  hashString,
-  hydrateRegExp,
-  isDefaultFieldConfigId,
-  isEmptyArray,
-  isEmptyObject,
-  isFunction,
   isHidden,
-  isInteger,
-  isNaN$1 as isNaN,
-  isObject,
-  isPlainObject,
   isPropertyBuilder,
   isReadOnly,
-  isValidRegExp,
-  mergeDeep,
-  mergeEntityActions,
-  navigateToEntity,
-  pick,
-  plural,
-  prettifyIdentifier,
-  randomColor,
-  randomString,
+  normalizeToEntityRelation,
   registerConditionOperations,
-  removeFunctions,
-  removeInPath,
   removeInitialAndTrailingSlashes,
   removeInitialSlash,
-  removeNulls,
-  removePropsIfExisting,
   removeTrailingSlash,
-  removeUndefined,
   resolveArrayProperties,
   resolveCollectionPathIds,
   resolveCollectionRelations,
   resolveDefaultSelectedView,
-  resolveEntityAction,
-  resolveEntityView$1 as resolveEntityView,
   resolveEnumValues,
   resolveProperties,
   resolveProperty,
@@ -2359,22 +2150,13 @@ export {
   resolveRelationProperty,
   resolveStorageFilenameString,
   resolveStoragePathString,
-  resolvedSelectedEntityView,
   sanitizeData,
   sanitizeRelation,
   segmentsToStrippedPath,
-  serializeRegExp,
-  setIn,
-  singular,
-  slugify,
   sortProperties,
   stripCollectionPath,
-  toArray,
-  toKebabCase,
-  toSnakeCase,
   traverseValueProperty,
   traverseValuesProperties,
-  unslugify,
   updateDateAutoValues
 };
 //# sourceMappingURL=index.es.js.map