@rebasepro/server-postgresql 0.0.1-canary.eae7889 → 0.1.0

package/dist/index.umd.js

@@ -132,7 +132,8 @@
   }
   const DEFAULT_ONE_OF_TYPE = "type";
   const DEFAULT_ONE_OF_VALUE = "value";
-  const snakeCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
+  const tokenizeRegex = /[A-Z]{2,}(?=[A-Z][a-z]|\b)|[A-Z]?[a-z]+|[0-9]+(?:[a-z](?![a-z]))?|[A-Z]/g;
+  const snakeCaseRegex = tokenizeRegex;
   const toSnakeCase = (str) => {
     const regExpMatchArray = str.match(snakeCaseRegex);
     if (!regExpMatchArray) return "";
@@ -1029,6 +1030,80 @@
     const singularName = snakeCaseName.endsWith("s") ? snakeCaseName.slice(0, -1) : snakeCaseName;
     return `${singularName}_id`;
   }
+  function updateDateAutoValues({
+    inputValues,
+    properties,
+    status,
+    timestampNowValue
+  }) {
+    return traverseValuesProperties(inputValues, properties, (inputValue, property) => {
+      if (property.type === "date") {
+        if (status === "existing" && property.autoValue === "on_update") {
+          return timestampNowValue;
+        } else if ((status === "new" || status === "copy") && (property.autoValue === "on_update" || property.autoValue === "on_create")) {
+          return timestampNowValue;
+        } else {
+          return inputValue;
+        }
+      } else {
+        return inputValue;
+      }
+    }) ?? {};
+  }
+  function traverseValuesProperties(inputValues, properties, operation) {
+    const safeInputValues = inputValues ?? {};
+    const updatedValues = Object.entries(properties).map(([key, property]) => {
+      const inputValue = safeInputValues && safeInputValues[key];
+      const updatedValue = traverseValueProperty(inputValue, property, operation);
+      if (updatedValue === null) return null;
+      if (updatedValue === void 0) return void 0;
+      return {
+        [key]: updatedValue
+      };
+    }).reduce((a, b) => ({
+      ...a,
+      ...b
+    }), {});
+    const result = mergeDeep(safeInputValues, updatedValues);
+    if (!result || Object.keys(result).length === 0) return void 0;
+    return result;
+  }
+  function traverseValueProperty(inputValue, property, operation) {
+    let value;
+    if (property.type === "map" && property.properties) {
+      value = traverseValuesProperties(inputValue, property.properties, operation);
+    } else if (property.type === "array") {
+      const of = property.of;
+      if (of && Array.isArray(inputValue) && !Array.isArray(of)) {
+        value = inputValue.map((e) => traverseValueProperty(e, of, operation));
+      } else if (of && Array.isArray(inputValue) && Array.isArray(of)) {
+        value = inputValue.map((e, i) => {
+          if (i < of.length) return traverseValueProperty(e, of[i], operation);
+          return null;
+        }).filter(Boolean);
+      } else if (property.oneOf && Array.isArray(inputValue)) {
+        const typeField = property.oneOf?.typeField ?? DEFAULT_ONE_OF_TYPE;
+        const valueField = property.oneOf?.valueField ?? DEFAULT_ONE_OF_VALUE;
+        value = inputValue.map((e) => {
+          if (e === null) return null;
+          if (typeof e !== "object") return e;
+          const rec = e;
+          const type = rec[typeField];
+          const childProperty = property.oneOf?.properties[type];
+          if (!type || !childProperty) return e;
+          return {
+            [typeField]: type,
+            [valueField]: traverseValueProperty(rec[valueField], childProperty, operation)
+          };
+        });
+      } else {
+        value = inputValue;
+      }
+    } else {
+      value = operation(inputValue, property);
+    }
+    return value;
+  }
   function createRelationRef(id, path2) {
     return {
       id,
@@ -1725,8 +1800,8 @@
       return jsonLogic;
     });
   })(logic);
-  var getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols;
-  var hasOwnProperty$a = Object.prototype.hasOwnProperty;
+  const { getOwnPropertyNames, getOwnPropertySymbols } = Object;
+  const { hasOwnProperty: hasOwnProperty$a } = Object.prototype;
   function combineComparators(comparatorA, comparatorB) {
     return function isEqual(a, b, state) {
       return comparatorA(a, b, state) && comparatorB(a, b, state);
@@ -1737,38 +1812,45 @@
       if (!a || !b || typeof a !== "object" || typeof b !== "object") {
         return areItemsEqual(a, b, state);
       }
-      var cache = state.cache;
-      var cachedA = cache.get(a);
-      var cachedB = cache.get(b);
+      const { cache } = state;
+      const cachedA = cache.get(a);
+      const cachedB = cache.get(b);
       if (cachedA && cachedB) {
         return cachedA === b && cachedB === a;
       }
       cache.set(a, b);
       cache.set(b, a);
-      var result = areItemsEqual(a, b, state);
+      const result = areItemsEqual(a, b, state);
       cache.delete(a);
       cache.delete(b);
       return result;
     };
   }
-  function getShortTag(value) {
-    return value != null ? value[Symbol.toStringTag] : void 0;
-  }
   function getStrictProperties(object) {
     return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
   }
-  var hasOwn = Object.hasOwn || function(object, property) {
-    return hasOwnProperty$a.call(object, property);
-  };
-  function sameValueZeroEqual(a, b) {
-    return a === b || !a && !b && a !== a && b !== b;
+  const hasOwn = (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    Object.hasOwn || ((object, property) => hasOwnProperty$a.call(object, property))
+  );
+  const PREACT_VNODE = "__v";
+  const PREACT_OWNER = "__o";
+  const REACT_OWNER = "_owner";
+  const { getOwnPropertyDescriptor, keys: keys$4 } = Object;
+  const sameValueEqual = (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    Object.is || function sameValueEqual2(a, b) {
+      return a === b ? a !== 0 || 1 / a === 1 / b : a !== a && b !== b;
+    }
+  );
+  function strictEqual(a, b) {
+    return a === b;
+  }
+  function areArrayBuffersEqual(a, b) {
+    return a.byteLength === b.byteLength && areTypedArraysEqual(new Uint8Array(a), new Uint8Array(b));
   }
-  var PREACT_VNODE = "__v";
-  var PREACT_OWNER = "__o";
-  var REACT_OWNER = "_owner";
-  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, keys$4 = Object.keys;
   function areArraysEqual(a, b, state) {
-    var index = a.length;
+    let index = a.length;
     if (b.length !== index) {
       return false;
     }
@@ -1779,35 +1861,35 @@
     }
     return true;
   }
+  function areDataViewsEqual(a, b) {
+    return a.byteLength === b.byteLength && areTypedArraysEqual(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength));
+  }
   function areDatesEqual(a, b) {
-    return sameValueZeroEqual(a.getTime(), b.getTime());
+    return sameValueEqual(a.getTime(), b.getTime());
   }
   function areErrorsEqual(a, b) {
     return a.name === b.name && a.message === b.message && a.cause === b.cause && a.stack === b.stack;
   }
-  function areFunctionsEqual(a, b) {
-    return a === b;
-  }
   function areMapsEqual(a, b, state) {
-    var size = a.size;
+    const size = a.size;
     if (size !== b.size) {
       return false;
     }
     if (!size) {
       return true;
     }
-    var matchedIndices = new Array(size);
-    var aIterable = a.entries();
-    var aResult;
-    var bResult;
-    var index = 0;
+    const matchedIndices = new Array(size);
+    const aIterable = a.entries();
+    let aResult;
+    let bResult;
+    let index = 0;
     while (aResult = aIterable.next()) {
       if (aResult.done) {
         break;
       }
-      var bIterable = b.entries();
-      var hasMatch = false;
-      var matchIndex = 0;
+      const bIterable = b.entries();
+      let hasMatch = false;
+      let matchIndex = 0;
       while (bResult = bIterable.next()) {
         if (bResult.done) {
           break;
@@ -1816,8 +1898,8 @@
           matchIndex++;
           continue;
         }
-        var aEntry = aResult.value;
-        var bEntry = bResult.value;
+        const aEntry = aResult.value;
+        const bEntry = bResult.value;
         if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) && state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {
           hasMatch = matchedIndices[matchIndex] = true;
           break;
@@ -1831,10 +1913,9 @@
     }
     return true;
   }
-  var areNumbersEqual = sameValueZeroEqual;
   function areObjectsEqual(a, b, state) {
-    var properties = keys$4(a);
-    var index = properties.length;
+    const properties = keys$4(a);
+    let index = properties.length;
     if (keys$4(b).length !== index) {
       return false;
     }
@@ -1846,14 +1927,14 @@
     return true;
   }
   function areObjectsEqualStrict(a, b, state) {
-    var properties = getStrictProperties(a);
-    var index = properties.length;
+    const properties = getStrictProperties(a);
+    let index = properties.length;
     if (getStrictProperties(b).length !== index) {
       return false;
     }
-    var property;
-    var descriptorA;
-    var descriptorB;
+    let property;
+    let descriptorA;
+    let descriptorB;
     while (index-- > 0) {
       property = properties[index];
       if (!isPropertyEqual(a, b, state, property)) {
@@ -1868,30 +1949,30 @@
     return true;
   }
   function arePrimitiveWrappersEqual(a, b) {
-    return sameValueZeroEqual(a.valueOf(), b.valueOf());
+    return sameValueEqual(a.valueOf(), b.valueOf());
   }
   function areRegExpsEqual(a, b) {
     return a.source === b.source && a.flags === b.flags;
   }
   function areSetsEqual(a, b, state) {
-    var size = a.size;
+    const size = a.size;
     if (size !== b.size) {
       return false;
     }
     if (!size) {
       return true;
     }
-    var matchedIndices = new Array(size);
-    var aIterable = a.values();
-    var aResult;
-    var bResult;
+    const matchedIndices = new Array(size);
+    const aIterable = a.values();
+    let aResult;
+    let bResult;
     while (aResult = aIterable.next()) {
       if (aResult.done) {
         break;
       }
-      var bIterable = b.values();
-      var hasMatch = false;
-      var matchIndex = 0;
+      const bIterable = b.values();
+      let hasMatch = false;
+      let matchIndex = 0;
       while (bResult = bIterable.next()) {
         if (bResult.done) {
           break;
@@ -1909,8 +1990,8 @@
     return true;
   }
   function areTypedArraysEqual(a, b) {
-    var index = a.length;
-    if (b.length !== index) {
+    let index = a.byteLength;
+    if (b.byteLength !== index || a.byteOffset !== b.byteOffset) {
       return false;
     }
     while (index-- > 0) {
@@ -1929,23 +2010,10 @@
     }
     return hasOwn(b, property) && state.equals(a[property], b[property], property, property, a, b, state);
   }
-  var ARGUMENTS_TAG = "[object Arguments]";
-  var BOOLEAN_TAG = "[object Boolean]";
-  var DATE_TAG = "[object Date]";
-  var ERROR_TAG = "[object Error]";
-  var MAP_TAG = "[object Map]";
-  var NUMBER_TAG = "[object Number]";
-  var OBJECT_TAG = "[object Object]";
-  var REG_EXP_TAG = "[object RegExp]";
-  var SET_TAG = "[object Set]";
-  var STRING_TAG = "[object String]";
-  var URL_TAG = "[object URL]";
-  var isArray$4 = Array.isArray;
-  var isTypedArray$2 = typeof ArrayBuffer === "function" && ArrayBuffer.isView ? ArrayBuffer.isView : null;
-  var assign = Object.assign;
-  var getTag$4 = Object.prototype.toString.call.bind(Object.prototype.toString);
-  function createEqualityComparator(_a) {
-    var areArraysEqual2 = _a.areArraysEqual, areDatesEqual2 = _a.areDatesEqual, areErrorsEqual2 = _a.areErrorsEqual, areFunctionsEqual2 = _a.areFunctionsEqual, areMapsEqual2 = _a.areMapsEqual, areNumbersEqual2 = _a.areNumbersEqual, areObjectsEqual2 = _a.areObjectsEqual, arePrimitiveWrappersEqual2 = _a.arePrimitiveWrappersEqual, areRegExpsEqual2 = _a.areRegExpsEqual, areSetsEqual2 = _a.areSetsEqual, areTypedArraysEqual2 = _a.areTypedArraysEqual, areUrlsEqual2 = _a.areUrlsEqual, unknownTagComparators = _a.unknownTagComparators;
+  const toString = Object.prototype.toString;
+  function createEqualityComparator(config) {
+    const supportedComparatorMap = createSupportedComparatorMap(config);
+    const { areArraysEqual: areArraysEqual2, areDatesEqual: areDatesEqual2, areFunctionsEqual, areMapsEqual: areMapsEqual2, areNumbersEqual, areObjectsEqual: areObjectsEqual2, areRegExpsEqual: areRegExpsEqual2, areSetsEqual: areSetsEqual2, getUnsupportedCustomComparator } = config;
     return function comparator(a, b, state) {
       if (a === b) {
         return true;
@@ -1953,32 +2021,29 @@
       if (a == null || b == null) {
         return false;
       }
-      var type = typeof a;
+      const type = typeof a;
       if (type !== typeof b) {
         return false;
       }
       if (type !== "object") {
-        if (type === "number") {
-          return areNumbersEqual2(a, b, state);
+        if (type === "number" || type === "bigint") {
+          return areNumbersEqual(a, b, state);
         }
         if (type === "function") {
-          return areFunctionsEqual2(a, b, state);
+          return areFunctionsEqual(a, b, state);
         }
         return false;
       }
-      var constructor = a.constructor;
+      const constructor = a.constructor;
       if (constructor !== b.constructor) {
         return false;
       }
       if (constructor === Object) {
         return areObjectsEqual2(a, b, state);
       }
-      if (isArray$4(a)) {
+      if (constructor === Array) {
         return areArraysEqual2(a, b, state);
       }
-      if (isTypedArray$2 != null && isTypedArray$2(a)) {
-        return areTypedArraysEqual2(a, b, state);
-      }
       if (constructor === Date) {
         return areDatesEqual2(a, b, state);
       }
@@ -1991,79 +2056,55 @@
       if (constructor === Set) {
         return areSetsEqual2(a, b, state);
       }
-      var tag = getTag$4(a);
-      if (tag === DATE_TAG) {
-        return areDatesEqual2(a, b, state);
-      }
-      if (tag === REG_EXP_TAG) {
-        return areRegExpsEqual2(a, b, state);
-      }
-      if (tag === MAP_TAG) {
-        return areMapsEqual2(a, b, state);
-      }
-      if (tag === SET_TAG) {
-        return areSetsEqual2(a, b, state);
-      }
-      if (tag === OBJECT_TAG) {
-        return typeof a.then !== "function" && typeof b.then !== "function" && areObjectsEqual2(a, b, state);
+      if (constructor === Promise) {
+        return false;
       }
-      if (tag === URL_TAG) {
-        return areUrlsEqual2(a, b, state);
+      if (Array.isArray(a)) {
+        return areArraysEqual2(a, b, state);
       }
-      if (tag === ERROR_TAG) {
-        return areErrorsEqual2(a, b, state);
+      const tag = toString.call(a);
+      const supportedComparator = supportedComparatorMap[tag];
+      if (supportedComparator) {
+        return supportedComparator(a, b, state);
       }
-      if (tag === ARGUMENTS_TAG) {
-        return areObjectsEqual2(a, b, state);
-      }
-      if (tag === BOOLEAN_TAG || tag === NUMBER_TAG || tag === STRING_TAG) {
-        return arePrimitiveWrappersEqual2(a, b, state);
-      }
-      if (unknownTagComparators) {
-        var unknownTagComparator = unknownTagComparators[tag];
-        if (!unknownTagComparator) {
-          var shortTag = getShortTag(a);
-          if (shortTag) {
-            unknownTagComparator = unknownTagComparators[shortTag];
-          }
-        }
-        if (unknownTagComparator) {
-          return unknownTagComparator(a, b, state);
-        }
+      const unsupportedCustomComparator = getUnsupportedCustomComparator && getUnsupportedCustomComparator(a, b, state, tag);
+      if (unsupportedCustomComparator) {
+        return unsupportedCustomComparator(a, b, state);
       }
       return false;
     };
   }
-  function createEqualityComparatorConfig(_a) {
-    var circular = _a.circular, createCustomConfig = _a.createCustomConfig, strict = _a.strict;
-    var config = {
+  function createEqualityComparatorConfig({ circular, createCustomConfig, strict }) {
+    let config = {
+      areArrayBuffersEqual,
       areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
+      areDataViewsEqual,
       areDatesEqual,
       areErrorsEqual,
-      areFunctionsEqual,
+      areFunctionsEqual: strictEqual,
       areMapsEqual: strict ? combineComparators(areMapsEqual, areObjectsEqualStrict) : areMapsEqual,
-      areNumbersEqual,
+      areNumbersEqual: sameValueEqual,
       areObjectsEqual: strict ? areObjectsEqualStrict : areObjectsEqual,
       arePrimitiveWrappersEqual,
       areRegExpsEqual,
       areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
-      areTypedArraysEqual: strict ? areObjectsEqualStrict : areTypedArraysEqual,
+      areTypedArraysEqual: strict ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict) : areTypedArraysEqual,
       areUrlsEqual,
-      unknownTagComparators: void 0
+      getUnsupportedCustomComparator: void 0
     };
     if (createCustomConfig) {
-      config = assign({}, config, createCustomConfig(config));
+      config = Object.assign({}, config, createCustomConfig(config));
     }
     if (circular) {
-      var areArraysEqual$1 = createIsCircular(config.areArraysEqual);
-      var areMapsEqual$1 = createIsCircular(config.areMapsEqual);
-      var areObjectsEqual$1 = createIsCircular(config.areObjectsEqual);
-      var areSetsEqual$1 = createIsCircular(config.areSetsEqual);
-      config = assign({}, config, {
-        areArraysEqual: areArraysEqual$1,
-        areMapsEqual: areMapsEqual$1,
-        areObjectsEqual: areObjectsEqual$1,
-        areSetsEqual: areSetsEqual$1
+      const areArraysEqual2 = createIsCircular(config.areArraysEqual);
+      const areMapsEqual2 = createIsCircular(config.areMapsEqual);
+      const areObjectsEqual2 = createIsCircular(config.areObjectsEqual);
+      const areSetsEqual2 = createIsCircular(config.areSetsEqual);
+      config = Object.assign({}, config, {
+        areArraysEqual: areArraysEqual2,
+        areMapsEqual: areMapsEqual2,
+        areObjectsEqual: areObjectsEqual2,
+        areSetsEqual: areSetsEqual2
       });
     }
     return config;
@@ -2073,11 +2114,10 @@
       return compare(a, b, state);
     };
   }
-  function createIsEqual(_a) {
-    var circular = _a.circular, comparator = _a.comparator, createState = _a.createState, equals = _a.equals, strict = _a.strict;
+  function createIsEqual({ circular, comparator, createState, equals, strict }) {
     if (createState) {
       return function isEqual(a, b) {
-        var _a2 = createState(), _b = _a2.cache, cache = _b === void 0 ? circular ? /* @__PURE__ */ new WeakMap() : void 0 : _b, meta = _a2.meta;
+        const { cache = circular ? /* @__PURE__ */ new WeakMap() : void 0, meta } = createState();
         return comparator(a, b, {
           cache,
           equals,
@@ -2096,7 +2136,7 @@
         });
       };
     }
-    var state = {
+    const state = {
       cache: void 0,
       equals,
       meta: void 0,
@@ -2106,7 +2146,50 @@
       return comparator(a, b, state);
     };
   }
-  var deepEqual = createCustomEqual();
+  function createSupportedComparatorMap({ areArrayBuffersEqual: areArrayBuffersEqual2, areArraysEqual: areArraysEqual2, areDataViewsEqual: areDataViewsEqual2, areDatesEqual: areDatesEqual2, areErrorsEqual: areErrorsEqual2, areFunctionsEqual, areMapsEqual: areMapsEqual2, areNumbersEqual, areObjectsEqual: areObjectsEqual2, arePrimitiveWrappersEqual: arePrimitiveWrappersEqual2, areRegExpsEqual: areRegExpsEqual2, areSetsEqual: areSetsEqual2, areTypedArraysEqual: areTypedArraysEqual2, areUrlsEqual: areUrlsEqual2 }) {
+    return {
+      "[object Arguments]": areObjectsEqual2,
+      "[object Array]": areArraysEqual2,
+      "[object ArrayBuffer]": areArrayBuffersEqual2,
+      "[object AsyncGeneratorFunction]": areFunctionsEqual,
+      "[object BigInt]": areNumbersEqual,
+      "[object BigInt64Array]": areTypedArraysEqual2,
+      "[object BigUint64Array]": areTypedArraysEqual2,
+      "[object Boolean]": arePrimitiveWrappersEqual2,
+      "[object DataView]": areDataViewsEqual2,
+      "[object Date]": areDatesEqual2,
+      // If an error tag, it should be tested explicitly. Like RegExp, the properties are not
+      // enumerable, and therefore will give false positives if tested like a standard object.
+      "[object Error]": areErrorsEqual2,
+      "[object Float16Array]": areTypedArraysEqual2,
+      "[object Float32Array]": areTypedArraysEqual2,
+      "[object Float64Array]": areTypedArraysEqual2,
+      "[object Function]": areFunctionsEqual,
+      "[object GeneratorFunction]": areFunctionsEqual,
+      "[object Int8Array]": areTypedArraysEqual2,
+      "[object Int16Array]": areTypedArraysEqual2,
+      "[object Int32Array]": areTypedArraysEqual2,
+      "[object Map]": areMapsEqual2,
+      "[object Number]": arePrimitiveWrappersEqual2,
+      "[object Object]": (a, b, state) => (
+        // The exception for value comparison is custom `Promise`-like class instances. These should
+        // be treated the same as standard `Promise` objects, which means strict equality, and if
+        // it reaches this point then that strict equality comparison has already failed.
+        typeof a.then !== "function" && typeof b.then !== "function" && areObjectsEqual2(a, b, state)
+      ),
+      // For RegExp, the properties are not enumerable, and therefore will give false positives if
+      // tested like a standard object.
+      "[object RegExp]": areRegExpsEqual2,
+      "[object Set]": areSetsEqual2,
+      "[object String]": arePrimitiveWrappersEqual2,
+      "[object URL]": areUrlsEqual2,
+      "[object Uint8Array]": areTypedArraysEqual2,
+      "[object Uint8ClampedArray]": areTypedArraysEqual2,
+      "[object Uint16Array]": areTypedArraysEqual2,
+      "[object Uint32Array]": areTypedArraysEqual2
+    };
+  }
+  const deepEqual = createCustomEqual();
   createCustomEqual({ strict: true });
   createCustomEqual({ circular: true });
   createCustomEqual({
@@ -2114,37 +2197,26 @@
     strict: true
   });
   createCustomEqual({
-    createInternalComparator: function() {
-      return sameValueZeroEqual;
-    }
+    createInternalComparator: () => sameValueEqual
   });
   createCustomEqual({
     strict: true,
-    createInternalComparator: function() {
-      return sameValueZeroEqual;
-    }
+    createInternalComparator: () => sameValueEqual
   });
   createCustomEqual({
     circular: true,
-    createInternalComparator: function() {
-      return sameValueZeroEqual;
-    }
+    createInternalComparator: () => sameValueEqual
   });
   createCustomEqual({
     circular: true,
-    createInternalComparator: function() {
-      return sameValueZeroEqual;
-    },
+    createInternalComparator: () => sameValueEqual,
     strict: true
   });
-  function createCustomEqual(options) {
-    if (options === void 0) {
-      options = {};
-    }
-    var _a = options.circular, circular = _a === void 0 ? false : _a, createCustomInternalComparator = options.createInternalComparator, createState = options.createState, _b = options.strict, strict = _b === void 0 ? false : _b;
-    var config = createEqualityComparatorConfig(options);
-    var comparator = createEqualityComparator(config);
-    var equals = createCustomInternalComparator ? createCustomInternalComparator(comparator) : createInternalEqualityComparator(comparator);
+  function createCustomEqual(options = {}) {
+    const { circular = false, createInternalComparator: createCustomInternalComparator, createState, strict = false } = options;
+    const config = createEqualityComparatorConfig(options);
+    const comparator = createEqualityComparator(config);
+    const equals = createCustomInternalComparator ? createCustomInternalComparator(comparator) : createInternalEqualityComparator(comparator);
     return createIsEqual({ circular, comparator, createState, equals, strict });
   }
   function listCacheClear$1() {
@@ -2619,8 +2691,8 @@
     var freeExports = exports$1 && !exports$1.nodeType && exports$1;
     var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
     var moduleExports = freeModule && freeModule.exports === freeExports;
-    var Buffer = moduleExports ? root2.Buffer : void 0;
-    var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+    var Buffer2 = moduleExports ? root2.Buffer : void 0;
+    var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
     var isBuffer2 = nativeIsBuffer || stubFalse2;
     module2.exports = isBuffer2;
   })(isBuffer$2, isBuffer$2.exports);
@@ -2785,7 +2857,7 @@
     var freeExports = exports$1 && !exports$1.nodeType && exports$1;
     var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
     var moduleExports = freeModule && freeModule.exports === freeExports;
-    var Buffer = moduleExports ? root2.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+    var Buffer2 = moduleExports ? root2.Buffer : void 0, allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : void 0;
     function cloneBuffer2(buffer, isDeep) {
       if (isDeep) {
         return buffer.slice();
@@ -3394,7 +3466,10 @@
         if (!relation) {
           throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'`);
         }
-        currentCollection = relation.target();
+        const target = relation.target();
+        const targetRelationKey = relation.relationName || target.slug;
+        const targetSlug = relation.overrides?.slug ?? targetRelationKey;
+        currentCollection = this.get(targetSlug) || this.normalizeCollection(target);
         if (i + 1 < pathSegments.length) ;
       }
       return currentCollection;
@@ -3443,7 +3518,7 @@
           if (!subcollection) {
             throw new Error(`Subcollection '${subcollectionSlug}' not found in ${currentCollection.slug}`);
           }
-          currentCollection = subcollection;
+          currentCollection = this.get(subcollection.slug) || this.normalizeCollection(subcollection);
           collections.push(currentCollection);
         }
       }
@@ -4485,7 +4560,25 @@
           return result;
         }
         return value;
+      case "string":
+        if (typeof value === "string") {
+          if (value.startsWith("data:application/octet-stream;base64,")) {
+            const base64Data = value.split(",")[1];
+            if (base64Data) {
+              return Buffer.from(base64Data, "base64");
+            }
+          }
+        }
+        return value;
       default:
+        if (typeof value === "string") {
+          if (value.startsWith("data:application/octet-stream;base64,")) {
+            const base64Data = value.split(",")[1];
+            if (base64Data) {
+              return Buffer.from(base64Data, "base64");
+            }
+          }
+        }
         return value;
     }
   }
@@ -4611,6 +4704,37 @@
       return value;
     }
     switch (property.type) {
+      case "string": {
+        if (typeof value === "string") return value;
+        let isBuffer2 = false;
+        let buf = null;
+        if (Buffer.isBuffer(value)) {
+          isBuffer2 = true;
+          buf = value;
+        } else if (typeof value === "object" && value !== null && value.type === "Buffer" && Array.isArray(value.data)) {
+          isBuffer2 = true;
+          buf = Buffer.from(value.data);
+        }
+        if (isBuffer2 && buf) {
+          let isPrintable = true;
+          for (let i = 0; i < buf.length; i++) {
+            const b = buf[i];
+            if ((b < 32 || b > 126) && b !== 9 && b !== 10 && b !== 13) {
+              isPrintable = false;
+              break;
+            }
+          }
+          return isPrintable ? buf.toString("utf8") : `data:application/octet-stream;base64,${buf.toString("base64")}`;
+        }
+        if (typeof value === "object" && value !== null) {
+          try {
+            return JSON.stringify(value);
+          } catch {
+            return String(value);
+          }
+        }
+        return String(value);
+      }
       case "relation":
         if (typeof value === "string" || typeof value === "number") {
           let relationDef = property.relation;
@@ -4694,8 +4818,29 @@
         }
         return null;
       }
-      default:
+      default: {
+        let isBuffer2 = false;
+        let buf = null;
+        if (Buffer.isBuffer(value)) {
+          isBuffer2 = true;
+          buf = value;
+        } else if (typeof value === "object" && value !== null && value.type === "Buffer" && Array.isArray(value.data)) {
+          isBuffer2 = true;
+          buf = Buffer.from(value.data);
+        }
+        if (isBuffer2 && buf) {
+          let isPrintable = true;
+          for (let i = 0; i < buf.length; i++) {
+            const b = buf[i];
+            if ((b < 32 || b > 126) && b !== 9 && b !== 10 && b !== 13) {
+              isPrintable = false;
+              break;
+            }
+          }
+          return isPrintable ? buf.toString("utf8") : `data:application/octet-stream;base64,${buf.toString("base64")}`;
+        }
         return value;
+      }
     }
   }
   function normalizeScalarValues(data, properties, collection, resolvedRelations, options) {
@@ -5963,6 +6108,10 @@
           await this.resolveJoinPathRelations(entity, collection, collectionPath, parsedId, databaseId);
           return entity;
         } catch (e) {
+          if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
+            console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+            console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+          }
           console.warn(`[EntityFetchService] db.query.findFirst failed for ${collectionPath}, falling back to db.select:`, e);
         }
       }
@@ -6023,6 +6172,10 @@
           const entities = results2.map((row) => this.drizzleResultToEntity(row, collection, collectionPath, idInfo, options.databaseId, idInfoArray));
           return entities;
         } catch (e) {
+          if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
+            console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+            console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+          }
           console.warn(`[EntityFetchService] db.query.findMany failed for ${collectionPath}, falling back to db.select:`, e);
         }
       }
@@ -6292,6 +6445,10 @@
           await this.resolveJoinPathRelationsBatchRest(restRows, collection, collectionPath, idInfoArray, include);
           return restRows;
         } catch (e) {
+          if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
+            console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+            console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+          }
           console.warn(`[fetchCollectionForRest] db.query.findMany failed for ${collectionPath}, falling back:`, e);
         }
       }
@@ -6372,6 +6529,10 @@
           await this.resolveJoinPathRelationsBatchRest([restRow], collection, collectionPath, idInfoArray, include);
           return restRow;
         } catch (e) {
+          if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
+            console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+            console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+          }
           console.warn(`[fetchEntityForRest] db.query.findFirst failed for ${collectionPath}, falling back:`, e);
         }
       }
@@ -6630,7 +6791,7 @@
                 targetColumnName = relation.localKey;
               } else if (relation.foreignKeyOnTarget) {
                 targetColumnName = relation.foreignKeyOnTarget;
-              } else if (relation.joinPath && relation.joinPath.length > 0) {
+              } else if (relation.joinPath && relation.joinPath.length === 1) {
                 const targetTableName = getTableName(targetCollection);
                 const relevantJoinStep = relation.joinPath.find((joinStep) => joinStep.table === targetTableName);
                 if (relevantJoinStep) {
@@ -6641,6 +6802,8 @@
                   const targetColumnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(relation.joinPath[0].on.to);
                   targetColumnName = targetColumnNames[0];
                 }
+              } else if (relation.joinPath && relation.joinPath.length > 1) {
+                break;
               } else {
                 throw new Error(`Relation '${relationKey}' lacks configuration for path-based saving.`);
               }
@@ -6763,22 +6926,78 @@
       const pgError = this.extractPgError(error);
       if (pgError) {
         const detail = pgError.detail;
+        const hint = pgError.hint;
         const constraint = pgError.constraint;
         const column = pgError.column;
         const table = pgError.table;
+        const dataType = pgError.dataType;
+        const pgMessage = pgError.message || "Unknown database error";
+        const suffix = hint ? ` Hint: ${hint}` : "";
+        const tableRef = table ?? collectionSlug;
         switch (pgError.code) {
           case "23503":
-            return new Error(detail ? `Foreign key constraint violated: ${detail}` : `Cannot save: a foreign key constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".`);
+            return new Error(detail ? `Foreign key constraint violated: ${detail}${suffix}` : `Cannot save: a foreign key constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".${suffix}`);
           case "23505":
-            return new Error(detail ? `Duplicate value: ${detail}` : `Cannot save: a unique constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".`);
+            return new Error(detail ? `Duplicate value: ${detail}${suffix}` : `Cannot save: a unique constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".${suffix}`);
           case "23502":
-            return new Error(`Missing required field: "${column ?? "unknown"}" in "${table ?? collectionSlug}" cannot be empty.`);
+            return new Error(`Missing required field: "${column ?? "unknown"}" in "${tableRef}" cannot be empty.${suffix}`);
           case "23514":
-            return new Error(`Validation failed: a check constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".`);
+            return new Error(`Validation failed: a check constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".${suffix}`);
+          case "22P02":
+            return new Error(`Invalid data format in "${collectionSlug}": ${pgMessage}${suffix}`);
+          case "22001":
+            return new Error(`Value too long for column "${column ?? "unknown"}" in "${tableRef}": ${pgMessage}${suffix}`);
+          case "22003":
+            return new Error(`Numeric value out of range for column "${column ?? "unknown"}" in "${tableRef}": ${pgMessage}${suffix}`);
+          case "42703":
+            return new Error(`Unknown column in "${tableRef}": ${pgMessage}. Check if your schema is up to date (run migrations).${suffix}`);
+          case "42P01":
+            return new Error(`Table not found for "${collectionSlug}": ${pgMessage}. Check if your schema is up to date (run migrations).${suffix}`);
+          default: {
+            const parts = [`Database error in "${collectionSlug}" [${pgError.code}]: ${pgMessage}`];
+            if (detail) parts.push(`Detail: ${detail}`);
+            if (column) parts.push(`Column: ${column}`);
+            if (dataType) parts.push(`Data type: ${dataType}`);
+            if (constraint) parts.push(`Constraint: ${constraint}`);
+            if (hint) parts.push(`Hint: ${hint}`);
+            return new Error(parts.join(". "));
+          }
+        }
+      }
+      const causeMessage = this.extractCauseMessage(error);
+      if (causeMessage) {
+        return new Error(`Database error in "${collectionSlug}": ${causeMessage}`);
+      }
+      if (error instanceof Error) {
+        const cleaned = this.stripSqlFromMessage(error.message, collectionSlug);
+        return new Error(cleaned);
+      }
+      return new Error(`Database error in "${collectionSlug}": ${String(error)}`);
+    }
+    /**
+     * Walk the error cause chain and return the deepest meaningful message.
+     */
+    extractCauseMessage(error) {
+      if (!error || typeof error !== "object") return null;
+      const err = error;
+      if (err.cause && typeof err.cause === "object") {
+        const deeper = this.extractCauseMessage(err.cause);
+        if (deeper) return deeper;
+        if (err.cause instanceof Error && err.cause.message) {
+          return err.cause.message;
         }
       }
-      if (error instanceof Error) return error;
-      return new Error(String(error));
+      return null;
+    }
+    /**
+     * Strip the raw SQL query from a Drizzle "Failed query: ..." message,
+     * keeping only the error description.
+     */
+    stripSqlFromMessage(message, collectionSlug) {
+      if (message.startsWith("Failed query:")) {
+        return `Failed to save entity in "${collectionSlug}". Check server logs for details.`;
+      }
+      return message;
     }
     /**
      * Extract the underlying PostgreSQL error from a Drizzle wrapper.
@@ -6787,7 +7006,7 @@
     extractPgError(error) {
       if (!error || typeof error !== "object") return null;
       const err = error;
-      if (err.code && /^[0-9]{5}$/.test(err.code)) {
+      if (err.code && /^[0-9A-Z]{5}$/.test(err.code)) {
         return err;
       }
       if (err.cause && typeof err.cause === "object") {
@@ -7075,6 +7294,7 @@
     branchService;
     user;
     data;
+    client;
     /**
      * When true, realtime notifications are deferred until after the
      * wrapping transaction commits.  Set by `withAuth` → `withTransaction`.
@@ -7103,6 +7323,14 @@
         } : {}
       };
     }
+    /**
+     * REST-optimised fetch service (include-aware eager-loading).
+     * Delegates to the underlying EntityFetchService which already
+     * implements the matching method signatures.
+     */
+    get restFetchService() {
+      return this.entityService.getFetchService();
+    }
     resolveCollectionCallbacks(collection, path2) {
       if (!collection && !path2) return {
         collection: void 0,
@@ -7156,7 +7384,8 @@
         const contextForCallback = {
           user: this.user,
           driver: this,
-          data: this.data
+          data: this.data,
+          client: this.client
         };
         return Promise.all(entities.map(async (entity) => {
           let fetched = entity;
@@ -7250,7 +7479,8 @@
         const contextForCallback = {
           user: this.user,
           driver: this,
-          data: this.data
+          data: this.data,
+          client: this.client
         };
         if (callbacks?.afterRead) {
           entity = await callbacks.afterRead({
@@ -7319,7 +7549,8 @@
       const contextForCallback = {
         user: this.user,
         driver: this,
-        data: this.data
+        data: this.data,
+        client: this.client
       };
       let previousValuesForHistory;
       if (status === "existing" && entityId) {
@@ -7354,6 +7585,14 @@
           if (result) updatedValues = mergeDeep(updatedValues, result);
         }
       }
+      if (resolvedCollection?.properties) {
+        updatedValues = updateDateAutoValues({
+          inputValues: updatedValues,
+          properties: resolvedCollection.properties,
+          status: status ?? "new",
+          timestampNowValue: /* @__PURE__ */ new Date()
+        });
+      }
       try {
         let savedEntity = await this.entityService.saveEntity(path2, updatedValues, entityId, resolvedCollection?.databaseId);
         if (savedEntity && (callbacks?.afterRead || propertyCallbacks?.afterRead)) {
@@ -7459,7 +7698,8 @@
       const contextForCallback = {
         user: this.user,
         driver: this,
-        data: this.data
+        data: this.data,
+        client: this.client
       };
       if (callbacks?.beforeDelete || propertyCallbacks?.beforeDelete) {
         if (callbacks?.beforeDelete) {
@@ -7786,6 +8026,7 @@
         txDelegate.entityService = txEntityService;
         txDelegate._deferNotifications = true;
         txDelegate._pendingNotifications = pendingNotifications;
+        txDelegate.client = this.delegate.client;
         return await operation(txDelegate);
       });
       for (const notification of pendingNotifications) {
@@ -8067,6 +8308,12 @@
       references: [users.id]
     })
   }));
+  const resolveColumnName = (propName, prop) => {
+    if (prop && "columnName" in prop && typeof prop.columnName === "string") {
+      return prop.columnName;
+    }
+    return toSnakeCase(propName);
+  };
   const getPrimaryKeyProp = (collection) => {
     if (collection.properties) {
       const idPropEntry = Object.entries(collection.properties).find(([_, prop]) => "isId" in prop && Boolean(prop.isId));
@@ -8107,7 +8354,7 @@
     return !hasExplicitId && propName === "id";
   };
   const getDrizzleColumn = (propName, prop, collection, collections) => {
-    const colName = toSnakeCase(propName);
+    const colName = resolveColumnName(propName, prop);
     let columnDefinition;
     switch (prop.type) {
       case "string": {
@@ -8179,6 +8426,9 @@
         } else {
           columnDefinition = `timestamp("${colName}", { withTimezone: true, mode: 'string' })`;
         }
+        if (dateProp.autoValue === "on_create" || dateProp.autoValue === "on_update") {
+          columnDefinition += `.default(sql\`now()\`)`;
+        }
         break;
       }
       case "map":
@@ -8211,7 +8461,7 @@
         } catch {
           return null;
         }
-        const fkColumnName = toSnakeCase(relation.localKey);
+        const fkColumnName = relation.localKey;
         const targetTableVar = getTableVarName(getTableName(targetCollection));
         const pkProp = getPrimaryKeyProp(targetCollection);
         const targetIdField = pkProp.name;
@@ -8399,7 +8649,7 @@
       Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
         if ("enum" in prop && (prop.type === "string" || prop.type === "number") && prop.enum) {
           const enumVarName = getEnumVarName(collectionPath, propName);
-          const enumDbName = `${collectionPath}_${toSnakeCase(propName)}`;
+          const enumDbName = `${collectionPath}_${resolveColumnName(propName, prop)}`;
           const values = Array.isArray(prop.enum) ? prop.enum.map((v) => String(v.id ?? v)) : Object.keys(prop.enum);
           if (values.length > 0) {
             schemaContent += `export const ${enumVarName} = pgEnum("${enumDbName}", [${values.map((v) => `'${v}'`).join(", ")}]);
@@ -8456,9 +8706,9 @@
         const targetId = getPrimaryKeyName(targetCollection);
         schemaContent += `export const ${tableVarName} = pgTable("${tableName}", {
 `;
-        schemaContent += `    ${sourceColumn}: ${sourceColType}("${toSnakeCase(sourceColumn)}").notNull().references(() => ${getTableVarName(getTableName(sourceCollection))}.${sourceId}, ${refOptions}),
+        schemaContent += `    ${sourceColumn}: ${sourceColType}("${sourceColumn}").notNull().references(() => ${getTableVarName(getTableName(sourceCollection))}.${sourceId}, ${refOptions}),
 `;
-        schemaContent += `    ${targetColumn}: ${targetColType}("${toSnakeCase(targetColumn)}").notNull().references(() => ${getTableVarName(getTableName(targetCollection))}.${targetId}, ${refOptions}),
+        schemaContent += `    ${targetColumn}: ${targetColType}("${targetColumn}").notNull().references(() => ${getTableVarName(getTableName(targetCollection))}.${targetId}, ${refOptions}),
 `;
         schemaContent += "}, (table) => ({\n";
         schemaContent += `    pk: primaryKey({ columns: [table.${sourceColumn}, table.${targetColumn}] })
@@ -8551,29 +8801,10 @@
         references: [${targetTableVar}.${getPrimaryKeyName(target)}],
         relationName: "${drizzleRelationName}"
     })`);
-              } else if (rel.direction === "inverse" && rel.foreignKeyOnTarget) {
-                const sourceIdField = getPrimaryKeyName(collection);
+              } else if (rel.direction === "inverse") {
                 tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {
-        fields: [${tableVarName}.${sourceIdField}],
-        references: [${targetTableVar}.${rel.foreignKeyOnTarget}],
         relationName: "${drizzleRelationName}"
     })`);
-              } else if (rel.direction === "inverse" && !rel.foreignKeyOnTarget) {
-                try {
-                  const targetCollection = rel.target();
-                  const targetResolvedRelations = resolveCollectionRelations(targetCollection);
-                  const correspondingRelation = Object.values(targetResolvedRelations).find((targetRel) => targetRel.direction === "owning" && targetRel.cardinality === "one" && targetRel.target().slug === collection.slug);
-                  if (correspondingRelation && correspondingRelation.localKey) {
-                    const sourceIdField = getPrimaryKeyName(collection);
-                    tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {
-        fields: [${tableVarName}.${sourceIdField}],
-        references: [${targetTableVar}.${correspondingRelation.localKey}],
-        relationName: "${drizzleRelationName}"
-    })`);
-                  }
-                } catch (e) {
-                  console.warn(`Could not resolve inverse one-to-one relation '${relationKey}':`, e);
-                }
               }
             } else if (rel.cardinality === "many") {
               if (rel.direction === "inverse" && rel.foreignKeyOnTarget) {
@@ -8601,6 +8832,32 @@
             console.warn(`Could not generate relation ${relationKey} for ${collection.name}:`, e);
           }
         }
+        for (const otherCollection of collections) {
+          if (otherCollection.slug === collection.slug) continue;
+          const otherRelations = resolveCollectionRelations(otherCollection);
+          for (const [otherKey, otherRel] of Object.entries(otherRelations)) {
+            if (otherRel.direction === "inverse" && otherRel.foreignKeyOnTarget) {
+              try {
+                const otherTarget = otherRel.target();
+                if (otherTarget.slug === collection.slug) {
+                  const drizzleRelationName = computeSharedRelationName(otherRel, otherCollection, collections);
+                  const deduplicationKey = `${drizzleRelationName}::owning`;
+                  if (!emittedRelationNames.has(deduplicationKey)) {
+                    const otherTableVar = getTableVarName(getTableName(otherCollection));
+                    const synthKey = `_synth_${otherTableVar}_${otherRel.foreignKeyOnTarget}`;
+                    tableRelations.push(`    "${synthKey}": one(${otherTableVar}, {
+        fields: [${tableVarName}.${otherRel.foreignKeyOnTarget}],
+        references: [${otherTableVar}.${getPrimaryKeyName(otherCollection)}],
+        relationName: "${drizzleRelationName}"
+    })`);
+                    emittedRelationNames.add(deduplicationKey);
+                  }
+                }
+              } catch (e) {
+              }
+            }
+          }
+        }
       }
       if (tableRelations.length > 0) {
         const relVarName = `${tableVarName}Relations`;