@rebasepro/server-postgresql 0.0.1-canary.e259309 → 0.0.1-canary.f81da60

package/dist/index.umd.js

@@ -1725,8 +1725,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 +1737,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 +1786,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 +1823,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 +1838,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 +1852,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 +1874,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 +1915,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 +1935,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 +1946,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 +1981,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 (tag === URL_TAG) {
-        return areUrlsEqual2(a, b, state);
-      }
-      if (tag === ERROR_TAG) {
-        return areErrorsEqual2(a, b, state);
+      if (constructor === Promise) {
+        return false;
       }
-      if (tag === ARGUMENTS_TAG) {
-        return areObjectsEqual2(a, b, state);
+      if (Array.isArray(a)) {
+        return areArraysEqual2(a, b, state);
       }
-      if (tag === BOOLEAN_TAG || tag === NUMBER_TAG || tag === STRING_TAG) {
-        return arePrimitiveWrappersEqual2(a, b, state);
+      const tag = toString.call(a);
+      const supportedComparator = supportedComparatorMap[tag];
+      if (supportedComparator) {
+        return supportedComparator(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 +2039,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 +2061,7 @@
         });
       };
     }
-    var state = {
+    const state = {
       cache: void 0,
       equals,
       meta: void 0,
@@ -2106,7 +2071,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 +2122,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() {
@@ -3394,7 +3391,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 +3443,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);
         }
       }
@@ -6630,7 +6630,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 +6641,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.`);
               }
@@ -7103,6 +7105,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,
@@ -8551,29 +8561,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) {