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

package/dist/index.es.js

@@ -124,7 +124,8 @@ function getDataSourceCapabilities(driver) {
 }
 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 "";
@@ -1021,6 +1022,80 @@ function generateForeignKeyName(name) {
   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,
@@ -1717,8 +1792,8 @@ var logic = { exports: {} };
     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);
@@ -1729,38 +1804,45 @@ function createIsCircular(areItemsEqual) {
     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;
   }
@@ -1771,35 +1853,35 @@ function areArraysEqual(a, b, state) {
   }
   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;
@@ -1808,8 +1890,8 @@ function areMapsEqual(a, b, state) {
         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;
@@ -1823,10 +1905,9 @@ function areMapsEqual(a, b, state) {
   }
   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;
   }
@@ -1838,14 +1919,14 @@ function areObjectsEqual(a, b, state) {
   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)) {
@@ -1860,30 +1941,30 @@ function areObjectsEqualStrict(a, b, state) {
   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;
@@ -1901,8 +1982,8 @@ function areSetsEqual(a, b, state) {
   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) {
@@ -1921,23 +2002,10 @@ function isPropertyEqual(a, b, state, property) {
   }
   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;
@@ -1945,32 +2013,29 @@ function createEqualityComparator(_a) {
     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);
     }
@@ -1983,79 +2048,55 @@ function createEqualityComparator(_a) {
     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;
@@ -2065,11 +2106,10 @@ function createInternalEqualityComparator(compare) {
     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,
@@ -2088,7 +2128,7 @@ function createIsEqual(_a) {
       });
     };
   }
-  var state = {
+  const state = {
     cache: void 0,
     equals,
     meta: void 0,
@@ -2098,7 +2138,50 @@ function createIsEqual(_a) {
     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({
@@ -2106,37 +2189,26 @@ createCustomEqual({
   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() {
@@ -2611,8 +2683,8 @@ isBuffer$2.exports;
   var freeExports = exports$1 && !exports$1.nodeType && exports$1;
   var freeModule = freeExports && true && module && !module.nodeType && module;
   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;
   module.exports = isBuffer2;
 })(isBuffer$2, isBuffer$2.exports);
@@ -2777,7 +2849,7 @@ _cloneBuffer.exports;
   var freeExports = exports$1 && !exports$1.nodeType && exports$1;
   var freeModule = freeExports && true && module && !module.nodeType && module;
   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();
@@ -3386,7 +3458,10 @@ class CollectionRegistry {
       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;
@@ -3435,7 +3510,7 @@ class CollectionRegistry {
         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);
       }
     }
@@ -4477,7 +4552,25 @@ function serializePropertyToServer(value, property) {
         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;
   }
 }
@@ -4603,6 +4696,37 @@ function parsePropertyFromServer(value, property, collection, propertyKey) {
     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;
@@ -4686,8 +4810,29 @@ function parsePropertyFromServer(value, property, collection, propertyKey) {
       }
       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) {
@@ -5955,6 +6100,10 @@ class EntityFetchService {
         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);
       }
     }
@@ -6015,6 +6164,10 @@ class EntityFetchService {
         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);
       }
     }
@@ -6284,6 +6437,10 @@ class EntityFetchService {
         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);
       }
     }
@@ -6364,6 +6521,10 @@ class EntityFetchService {
         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);
       }
     }
@@ -6622,7 +6783,7 @@ class EntityPersistService {
               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) {
@@ -6633,6 +6794,8 @@ class EntityPersistService {
                 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.`);
             }
@@ -6755,22 +6918,78 @@ class EntityPersistService {
     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.
@@ -6779,7 +6998,7 @@ class EntityPersistService {
   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") {
@@ -7067,6 +7286,7 @@ class PostgresBackendDriver {
   branchService;
   user;
   data;
+  client;
   /**
    * When true, realtime notifications are deferred until after the
    * wrapping transaction commits.  Set by `withAuth` → `withTransaction`.
@@ -7095,6 +7315,14 @@ class PostgresBackendDriver {
       } : {}
     };
   }
+  /**
+   * 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,
@@ -7148,7 +7376,8 @@ class PostgresBackendDriver {
       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;
@@ -7242,7 +7471,8 @@ class PostgresBackendDriver {
       const contextForCallback = {
         user: this.user,
         driver: this,
-        data: this.data
+        data: this.data,
+        client: this.client
       };
       if (callbacks?.afterRead) {
         entity = await callbacks.afterRead({
@@ -7311,7 +7541,8 @@ class PostgresBackendDriver {
     const contextForCallback = {
       user: this.user,
       driver: this,
-      data: this.data
+      data: this.data,
+      client: this.client
     };
     let previousValuesForHistory;
     if (status === "existing" && entityId) {
@@ -7346,6 +7577,14 @@ class PostgresBackendDriver {
         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)) {
@@ -7451,7 +7690,8 @@ class PostgresBackendDriver {
     const contextForCallback = {
       user: this.user,
       driver: this,
-      data: this.data
+      data: this.data,
+      client: this.client
     };
     if (callbacks?.beforeDelete || propertyCallbacks?.beforeDelete) {
       if (callbacks?.beforeDelete) {
@@ -7778,6 +8018,7 @@ class AuthenticatedPostgresBackendDriver {
       txDelegate.entityService = txEntityService;
       txDelegate._deferNotifications = true;
       txDelegate._pendingNotifications = pendingNotifications;
+      txDelegate.client = this.delegate.client;
       return await operation(txDelegate);
     });
     for (const notification of pendingNotifications) {
@@ -8059,6 +8300,12 @@ const userIdentitiesRelations = relations(userIdentities, ({
     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));
@@ -8099,7 +8346,7 @@ const isIdProperty = (propName, prop, collection) => {
   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": {
@@ -8171,6 +8418,9 @@ const getDrizzleColumn = (propName, prop, collection, collections) => {
       } else {
         columnDefinition = `timestamp("${colName}", { withTimezone: true, mode: 'string' })`;
       }
+      if (dateProp.autoValue === "on_create" || dateProp.autoValue === "on_update") {
+        columnDefinition += `.default(sql\`now()\`)`;
+      }
       break;
     }
     case "map":
@@ -8203,7 +8453,7 @@ const getDrizzleColumn = (propName, prop, collection, collections) => {
       } 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;
@@ -8391,7 +8641,7 @@ const generateSchema = async (collections, stripPolicies = false) => {
     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(", ")}]);
@@ -8448,9 +8698,9 @@ const generateSchema = async (collections, stripPolicies = false) => {
       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}] })
@@ -8543,29 +8793,10 @@ const generateSchema = async (collections, stripPolicies = false) => {
         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) {
@@ -8593,6 +8824,32 @@ const generateSchema = async (collections, stripPolicies = false) => {
           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`;