@rebasepro/server-postgresql 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/dist/index.umd.js

@@ -1,6 +1,6 @@
 (function(global2, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("pg"), require("drizzle-orm/node-postgres"), require("drizzle-orm"), require("drizzle-orm/pg-core"), require("fs"), require("path"), require("url"), require("chokidar"), require("ws"), require("events"), require("crypto"), require("util"), require("@rebasepro/server-core")) : typeof define === "function" && define.amd ? define(["exports", "pg", "drizzle-orm/node-postgres", "drizzle-orm", "drizzle-orm/pg-core", "fs", "path", "url", "chokidar", "ws", "events", "crypto", "util", "@rebasepro/server-core"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2["Rebase Backend"] = {}, global2.pg, global2.nodePostgres, global2.drizzleOrm, global2.pgCore, global2.fs, global2.path, global2.url, global2.chokidar, global2.ws, global2.events, global2.crypto, global2.util, global2.serverCore));
-})(this, function(exports2, pg, nodePostgres, drizzleOrm, pgCore, fs, path, url, chokidar, ws, events, crypto, util, serverCore) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("pg"), require("drizzle-orm/node-postgres"), require("drizzle-orm"), require("drizzle-orm/pg-core"), require("crypto"), require("fs"), require("path"), require("url"), require("chokidar"), require("ws"), require("events"), require("util"), require("@rebasepro/server-core")) : typeof define === "function" && define.amd ? define(["exports", "pg", "drizzle-orm/node-postgres", "drizzle-orm", "drizzle-orm/pg-core", "crypto", "fs", "path", "url", "chokidar", "ws", "events", "util", "@rebasepro/server-core"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2["Rebase Backend"] = {}, global2.pg, global2.nodePostgres, global2.drizzleOrm, global2.pgCore, global2.crypto, global2.fs, global2.path, global2.url, global2.chokidar, global2.ws, global2.events, global2.util, global2.serverCore));
+})(this, function(exports2, pg, nodePostgres, drizzleOrm, pgCore, crypto, fs, path, url, chokidar, ws, events, util, serverCore) {
   "use strict";
   var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
   function _interopNamespaceDefault(e) {
@@ -20,64 +20,118 @@
     return Object.freeze(n);
   }
   const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
-  function createPostgresDatabaseConnection(connectionString, schema) {
-    const pool = new pg.Pool({
+  const DEFAULT_POOL = {
+    max: 20,
+    idleTimeoutMillis: 3e4,
+    connectionTimeoutMillis: 1e4,
+    queryTimeout: 3e4,
+    statementTimeout: 3e4,
+    keepAlive: true
+  };
+  function createPostgresDatabaseConnection(connectionString, schema, poolConfig) {
+    const opts = {
+      ...DEFAULT_POOL,
+      ...poolConfig
+    };
+    const pgPoolConfig = {
       connectionString,
-      // Connection pool settings for resilience
-      max: 20,
-      // Maximum number of connections in the pool
-      idleTimeoutMillis: 3e4,
-      // Close idle connections after 30 seconds
-      connectionTimeoutMillis: 1e4,
-      // Timeout for new connections
-      // Retry configuration
-      query_timeout: 3e4,
-      // Query timeout
-      statement_timeout: 3e4,
-      // Statement timeout
-      // Keep connections alive
-      keepAlive: true,
+      max: opts.max,
+      idleTimeoutMillis: opts.idleTimeoutMillis,
+      connectionTimeoutMillis: opts.connectionTimeoutMillis,
+      query_timeout: opts.queryTimeout,
+      statement_timeout: opts.statementTimeout,
+      keepAlive: opts.keepAlive,
       keepAliveInitialDelayMillis: 0
-    });
+    };
+    const pool = new pg.Pool(pgPoolConfig);
     pool.on("error", (err) => {
-      console.error("Database connection error:", err);
+      console.error("[pg-pool] Unexpected pool error:", err.message);
       if (err.message.includes("ETIMEDOUT")) {
-        console.warn("Connection timeout detected, pool will automatically retry...");
+        console.warn("[pg-pool] Connection timeout detected — pool will auto-retry");
       }
     });
-    pool.on("connect", (client) => {
-      console.debug("Database client connected");
-      client.on("error", (err) => {
-        console.error("Database client error:", err);
-      });
-    });
-    pool.on("remove", (client) => {
-      console.debug("Database client removed from pool");
-    });
     const db = schema ? nodePostgres.drizzle(pool, {
       schema
     }) : nodePostgres.drizzle(pool);
-    process.on("SIGINT", async () => {
-      console.log("SIGINT: Closing database pool...");
-      await pool.end();
-      process.exit(0);
-    });
-    process.on("SIGTERM", async () => {
-      console.log("SIGTERM: Closing database pool...");
-      await pool.end();
-      process.exit(0);
-    });
     return {
       db,
+      pool,
       connectionString
     };
   }
   function isPostgresCollection(collection) {
     return !collection.driver || collection.driver === "postgres";
   }
-  function isFirebaseCollection(collection) {
-    return collection.driver === "firestore";
+  function isSQLAdmin(admin) {
+    return !!admin && typeof admin.executeSql === "function";
+  }
+  function isSchemaAdmin(admin) {
+    return !!admin && (typeof admin.fetchUnmappedTables === "function" || typeof admin.fetchTableMetadata === "function");
+  }
+  const POSTGRES_CAPABILITIES = {
+    key: "postgres",
+    label: "PostgreSQL",
+    supportsRelations: true,
+    supportsSubcollections: false,
+    supportsRLS: true,
+    supportsReferences: false,
+    supportsColumnTypes: true,
+    supportsRealtime: true,
+    supportsSQLAdmin: true,
+    supportsDocumentAdmin: false,
+    supportsSchemaAdmin: true
+  };
+  const FIREBASE_CAPABILITIES = {
+    key: "firestore",
+    label: "Firebase / Firestore",
+    supportsRelations: false,
+    supportsSubcollections: true,
+    supportsRLS: false,
+    supportsReferences: true,
+    supportsColumnTypes: false,
+    supportsRealtime: true,
+    supportsSQLAdmin: false,
+    supportsDocumentAdmin: false,
+    supportsSchemaAdmin: false
+  };
+  const MONGODB_CAPABILITIES = {
+    key: "mongodb",
+    label: "MongoDB",
+    supportsRelations: false,
+    supportsSubcollections: true,
+    supportsRLS: false,
+    supportsReferences: true,
+    supportsColumnTypes: false,
+    supportsRealtime: false,
+    supportsSQLAdmin: false,
+    supportsDocumentAdmin: true,
+    supportsSchemaAdmin: true
+  };
+  const DEFAULT_CAPABILITIES = {
+    key: "(default)",
+    label: "Default",
+    supportsRelations: true,
+    supportsSubcollections: true,
+    supportsRLS: true,
+    supportsReferences: true,
+    supportsColumnTypes: true,
+    supportsRealtime: true,
+    supportsSQLAdmin: true,
+    supportsDocumentAdmin: true,
+    supportsSchemaAdmin: true
+  };
+  const CAPABILITIES_REGISTRY = {
+    postgres: POSTGRES_CAPABILITIES,
+    firestore: FIREBASE_CAPABILITIES,
+    mongodb: MONGODB_CAPABILITIES,
+    "(default)": DEFAULT_CAPABILITIES
+  };
+  function getDataSourceCapabilities(driver) {
+    if (!driver) return POSTGRES_CAPABILITIES;
+    return CAPABILITIES_REGISTRY[driver] ?? DEFAULT_CAPABILITIES;
   }
+  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 toSnakeCase = (str) => {
     const regExpMatchArray = str.match(snakeCaseRegex);
@@ -975,6 +1029,21 @@
     const singularName = snakeCaseName.endsWith("s") ? snakeCaseName.slice(0, -1) : snakeCaseName;
     return `${singularName}_id`;
   }
+  function createRelationRef(id, path2) {
+    return {
+      id,
+      path: path2,
+      __type: "relation"
+    };
+  }
+  function createRelationRefWithData(id, path2, data) {
+    return {
+      id,
+      path: path2,
+      __type: "relation",
+      data
+    };
+  }
   function enumToObjectEntries(enumValues) {
     if (Array.isArray(enumValues)) {
       return enumValues;
@@ -998,15 +1067,35 @@
     if (collection.childCollections) {
       return collection.childCollections() ?? [];
     }
-    if (isFirebaseCollection(collection) && collection.subcollections) {
+    if (getDataSourceCapabilities(collection.driver).supportsSubcollections && collection.subcollections) {
       return collection.subcollections() ?? [];
     }
-    if (isPostgresCollection(collection) && collection.relations) {
+    if (getDataSourceCapabilities(collection.driver).supportsRelations && collection.relations) {
       const manyRelations = collection.relations.filter((r) => r.cardinality === "many");
       return manyRelations.map((r) => {
         const target = r.target();
-        return r.overrides ? mergeDeep(target, r.overrides) : target;
-      });
+        if (!target) return void 0;
+        const relationKey = r.relationName || target.slug;
+        let customName;
+        if (collection.properties) {
+          const prop = Object.entries(collection.properties).find(([_, p]) => p.type === "relation" && p.relationName === relationKey);
+          if (prop && prop[1].name) {
+            customName = prop[1].name;
+          }
+        }
+        const baseOverrides = {
+          slug: relationKey
+        };
+        if (customName) {
+          baseOverrides.name = customName;
+          baseOverrides.singularName = customName;
+        }
+        const targetWithOverrides = {
+          ...target,
+          ...baseOverrides
+        };
+        return r.overrides ? mergeDeep(targetWithOverrides, r.overrides) : targetWithOverrides;
+      }).filter((c) => Boolean(c));
     }
     return [];
   }
@@ -1113,7 +1202,7 @@
         if (!newRelation.foreignKeyOnTarget) {
           let foundForeignKey = false;
           try {
-            const targetRelations = targetCollection.relations || [];
+            const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? targetCollection.relations || [] : [];
             for (const targetRel of targetRelations) {
               if (targetRel.direction === "owning" && targetRel.cardinality === "one" && targetRel.localKey) {
                 try {
@@ -1139,7 +1228,7 @@
         let isManyToManyInverse = false;
         if (newRelation.inverseRelationName && !newRelation.foreignKeyOnTarget) {
           try {
-            const targetRelations = targetCollection.relations || [];
+            const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? targetCollection.relations || [] : [];
             for (const targetRel of targetRelations) {
               if (targetRel.cardinality === "many" && (targetRel.direction === "owning" || !targetRel.direction) && targetRel.relationName === newRelation.inverseRelationName) {
                 isManyToManyInverse = true;
@@ -1173,14 +1262,21 @@
     }
     return newRelation;
   }
+  const _resolvedRelationsCache = /* @__PURE__ */ new WeakMap();
   function resolveCollectionRelations(collection) {
+    const cached = _resolvedRelationsCache.get(collection);
+    if (cached) return cached;
+    if (!getDataSourceCapabilities(collection.driver).supportsRelations) return {};
+    const relCollection = collection;
     const relations = {};
-    if (collection.relations) {
-      collection.relations.forEach((relation) => {
+    const registeredRelationNames = /* @__PURE__ */ new Set();
+    if (relCollection.relations) {
+      relCollection.relations.forEach((relation) => {
         const normalizedRelation = sanitizeRelation(relation, collection);
         const relationKey = normalizedRelation.relationName;
         if (relationKey) {
           relations[relationKey] = normalizedRelation;
+          registeredRelationNames.add(relationKey);
         }
       });
     }
@@ -1192,15 +1288,17 @@
           sourceCollection: collection
         });
         if (relation) {
-          if (!relations[propKey]) {
-            if (!relation.relationName) {
-              relation.relationName = propKey;
-            }
-            relations[propKey] = sanitizeRelation(relation, collection);
+          if (relations[propKey]) return;
+          if (!relation.relationName) {
+            relation.relationName = propKey;
           }
+          const normalizedRelation = sanitizeRelation(relation, collection);
+          relations[propKey] = normalizedRelation;
+          registeredRelationNames.add(normalizedRelation.relationName ?? propKey);
         }
       });
     }
+    _resolvedRelationsCache.set(collection, relations);
     return relations;
   }
   function resolvePropertyRelation({
@@ -1209,7 +1307,24 @@
     sourceCollection
   }) {
     if (property.type !== "relation") return void 0;
-    const relation = (sourceCollection.relations ?? []).find((rel) => rel.relationName === property.relationName);
+    const relProp = property;
+    if (relProp.target) {
+      return {
+        relationName: relProp.relationName || propertyKey,
+        target: relProp.target,
+        cardinality: relProp.cardinality || "one",
+        direction: relProp.direction || "owning",
+        inverseRelationName: relProp.inverseRelationName,
+        localKey: relProp.localKey,
+        foreignKeyOnTarget: relProp.foreignKeyOnTarget,
+        through: relProp.through,
+        joinPath: relProp.joinPath,
+        onUpdate: relProp.onUpdate,
+        onDelete: relProp.onDelete,
+        overrides: relProp.overrides
+      };
+    }
+    const relation = (sourceCollection.relations ?? []).find((rel) => rel.relationName === relProp.relationName);
     if (!relation) {
       console.warn(`Unrecognized relation format for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
       return void 0;
@@ -1217,7 +1332,7 @@
     return relation;
   }
   function getTableName(collection) {
-    if (isPostgresCollection(collection)) {
+    if (getDataSourceCapabilities(collection.driver).supportsRelations) {
       return collection.table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
     }
     return toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
@@ -1233,6 +1348,14 @@
   function getColumnName(fullColumn) {
     return fullColumn.includes(".") ? fullColumn.split(".").pop() : fullColumn;
   }
+  function findRelation(resolvedRelations, key) {
+    if (resolvedRelations[key]) return resolvedRelations[key];
+    const slugKey = key.replace(/_/g, "-");
+    if (slugKey !== key && resolvedRelations[slugKey]) return resolvedRelations[slugKey];
+    const snakeKey = key.replace(/-/g, "_");
+    if (snakeKey !== key && resolvedRelations[snakeKey]) return resolvedRelations[snakeKey];
+    return void 0;
+  }
   var logic = { exports: {} };
   (function(module2, exports$1) {
     (function(root2, factory) {
@@ -3005,10 +3128,12 @@
     collectionsByTableName = /* @__PURE__ */ new Map();
     collectionsBySlug = /* @__PURE__ */ new Map();
     rootCollections = [];
+    cachedCollectionsList = null;
     // Raw configuration layer (used by Collection Editor AST generator)
     rawCollectionsByTableName = /* @__PURE__ */ new Map();
     rawCollectionsBySlug = /* @__PURE__ */ new Map();
     rawRootCollections = [];
+    cachedRawCollectionsList = null;
     // Snapshot of raw input for idempotency check — compared BEFORE normalization
     // to avoid the issue where normalization creates new objects that always fail equality.
     lastRawInputSnapshot = null;
@@ -3021,9 +3146,11 @@
       this.collectionsByTableName.clear();
       this.collectionsBySlug.clear();
       this.rootCollections = [];
+      this.cachedCollectionsList = null;
       this.rawCollectionsByTableName.clear();
       this.rawCollectionsBySlug.clear();
       this.rawRootCollections = [];
+      this.cachedRawCollectionsList = null;
     }
     /**
      * Registers a collection and its subcollections recursively.
@@ -3056,12 +3183,14 @@
           this.rawCollectionsBySlug.set(raw.slug, raw);
         }
       });
-      normalizedCollections.forEach((c, index) => {
+      normalizedCollections.forEach((c) => {
         const subcollections = getSubcollections(c);
-        const rawSubcollections = getSubcollections(collections[index]);
-        if (subcollections && rawSubcollections) {
-          subcollections.forEach((subCollection, subIndex) => {
-            this._registerRecursively(this.normalizeCollection(subCollection), cloneDeep(rawSubcollections[subIndex]));
+        if (subcollections && subcollections.length > 0) {
+          subcollections.forEach((subCollection) => {
+            if (!subCollection) return;
+            this._registerRecursively(this.normalizeCollection({
+              ...subCollection
+            }), cloneDeep(subCollection));
           });
         }
       });
@@ -3087,41 +3216,100 @@
       if (rawCollection.slug) {
         this.rawCollectionsBySlug.set(rawCollection.slug, rawCollection);
       }
-      const subcollections = getSubcollections(collection);
-      const rawSubcollections = getSubcollections(rawCollection);
-      if (subcollections && rawSubcollections) {
-        subcollections.forEach((subCollection, index) => {
-          this._registerRecursively(this.normalizeCollection(subCollection), cloneDeep(rawSubcollections[index]));
+      const subcollections = getSubcollections(normalizedCollection);
+      if (subcollections && subcollections.length > 0) {
+        subcollections.forEach((subCollection) => {
+          if (!subCollection) return;
+          this._registerRecursively(this.normalizeCollection({
+            ...subCollection
+          }), cloneDeep(subCollection));
         });
       }
     }
     normalizeCollection(collection) {
-      const relations = isPostgresCollection(collection) ? collection.relations ?? [] : [];
-      const properties = this.normalizeProperties(collection.properties, relations);
-      collection.properties = properties;
-      if (!collection.childCollections) {
-        if (isFirebaseCollection(collection) && collection.subcollections) {
-          collection.childCollections = collection.subcollections;
-        } else if (isPostgresCollection(collection) && collection.relations) {
-          const manyRelations = collection.relations.filter((r) => r.cardinality === "many");
+      const result = {
+        ...collection
+      };
+      const extractedRelations = this.extractRelationsFromProperties(result.properties);
+      const relResult = result;
+      const manualRelations = getDataSourceCapabilities(result.driver).supportsRelations ? relResult.relations ?? [] : [];
+      const mergedRelationsRaw = [...extractedRelations];
+      for (const manual of manualRelations) {
+        const name = manual.relationName;
+        if (!name || !mergedRelationsRaw.find((r) => r.relationName === name)) {
+          mergedRelationsRaw.push(manual);
+        }
+      }
+      let mergedRelations = mergedRelationsRaw;
+      if (getDataSourceCapabilities(result.driver).supportsRelations) {
+        mergedRelations = mergedRelationsRaw.map((r) => {
+          try {
+            return sanitizeRelation(r, result);
+          } catch {
+            return r;
+          }
+        });
+        relResult.relations = mergedRelations;
+      }
+      const properties = this.normalizeProperties(result.properties, mergedRelations);
+      result.properties = properties;
+      if (!result.childCollections) {
+        if (getDataSourceCapabilities(result.driver).supportsSubcollections && result.subcollections) {
+          result.childCollections = result.subcollections;
+        } else if (getDataSourceCapabilities(result.driver).supportsRelations && relResult.relations) {
+          const manyRelations = relResult.relations.filter((r) => r.cardinality === "many");
           if (manyRelations.length > 0) {
-            collection.childCollections = () => manyRelations.map((r) => {
+            result.childCollections = () => manyRelations.map((r) => {
               const target = r.target();
               return r.overrides ? mergeDeep(target, r.overrides) : target;
             });
           }
         }
       }
-      return collection;
+      return result;
+    }
+    /**
+     * Extract Relation[] from properties that have inline relation config (i.e. `target` is set).
+     * This allows developers to define relations directly on properties without a separate
+     * `relations[]` entry on the collection.
+     */
+    extractRelationsFromProperties(properties) {
+      const relations = [];
+      for (const [key, property] of Object.entries(properties)) {
+        if (property.type === "relation") {
+          const relProp = property;
+          const target = relProp.target ?? relProp.relation?.target;
+          if (target) {
+            const relationName = relProp.relationName ?? relProp.relation?.relationName ?? key;
+            relations.push({
+              relationName,
+              target,
+              cardinality: relProp.cardinality ?? relProp.relation?.cardinality ?? "one",
+              direction: relProp.direction ?? relProp.relation?.direction ?? "owning",
+              inverseRelationName: relProp.inverseRelationName ?? relProp.relation?.inverseRelationName,
+              localKey: relProp.localKey ?? relProp.relation?.localKey,
+              foreignKeyOnTarget: relProp.foreignKeyOnTarget ?? relProp.relation?.foreignKeyOnTarget,
+              through: relProp.through ?? relProp.relation?.through,
+              joinPath: relProp.joinPath ?? relProp.relation?.joinPath,
+              onUpdate: relProp.onUpdate ?? relProp.relation?.onUpdate,
+              onDelete: relProp.onDelete ?? relProp.relation?.onDelete,
+              overrides: relProp.overrides ?? relProp.relation?.overrides
+            });
+          }
+        } else if (property.type === "map" && property.properties) {
+          relations.push(...this.extractRelationsFromProperties(property.properties));
+        }
+      }
+      return relations;
     }
     normalizeProperties(properties, relations) {
       const newProperties = {};
       for (const key in properties) {
-        newProperties[key] = this.normalizeProperty(properties[key], relations);
+        newProperties[key] = this.normalizeProperty(key, properties[key], relations);
       }
       return newProperties;
     }
-    normalizeProperty(property, relations) {
+    normalizeProperty(key, property, relations) {
       const newProperty = {
         ...property
       };
@@ -3131,9 +3319,9 @@
         const arrayProp = newProperty;
         if (arrayProp.of) {
           if (Array.isArray(arrayProp.of)) {
-            arrayProp.of = arrayProp.of.map((p) => this.normalizeProperty(p, relations));
+            arrayProp.of = arrayProp.of.map((p, i) => this.normalizeProperty(`${key}[${i}]`, p, relations));
           } else {
-            arrayProp.of = this.normalizeProperty(arrayProp.of, relations);
+            arrayProp.of = this.normalizeProperty(`${key}.of`, arrayProp.of, relations);
           }
         } else if (arrayProp.oneOf && arrayProp.oneOf.properties) {
           arrayProp.oneOf.properties = this.normalizeProperties(arrayProp.oneOf.properties, relations);
@@ -3145,11 +3333,12 @@
         }
       } else if (newProperty.type === "relation") {
         const relationProperty = newProperty;
-        const relation = relations.find((r) => r.relationName === relationProperty.relationName);
+        const name = relationProperty.relationName || key;
+        const relation = relations.find((r) => r.relationName === name);
         if (relation) {
           relationProperty.relation = relation;
         } else {
-          console.warn(`Could not find relation for property with relationName: ${relationProperty.relationName}`);
+          console.warn(`Could not find relation for property '${key}' with relationName: ${name}`);
         }
       }
       return newProperty;
@@ -3157,6 +3346,11 @@
     get(path2) {
       const bySlug = this.collectionsBySlug.get(path2);
       if (bySlug) return bySlug;
+      if (path2.includes("-")) {
+        const normalized = path2.replace(/-/g, "_");
+        const byNormalized = this.collectionsBySlug.get(normalized);
+        if (byNormalized) return byNormalized;
+      }
       return this.collectionsByTableName.get(path2);
     }
     /**
@@ -3166,6 +3360,11 @@
     getRaw(path2) {
       const bySlug = this.rawCollectionsBySlug.get(path2);
       if (bySlug) return bySlug;
+      if (path2.includes("-")) {
+        const normalized = path2.replace(/-/g, "_");
+        const byNormalized = this.rawCollectionsBySlug.get(normalized);
+        if (byNormalized) return byNormalized;
+      }
       return this.rawCollectionsByTableName.get(path2);
     }
     /**
@@ -3187,11 +3386,11 @@
       }
       for (let i = 2; i < pathSegments.length; i += 2) {
         const relationKey = pathSegments[i];
-        if (!isPostgresCollection(currentCollection)) {
-          throw new Error(`Relation path navigation requires a PostgreSQL collection, but '${currentCollection.slug}' uses driver '${currentCollection.driver}'`);
+        if (!getDataSourceCapabilities(currentCollection.driver).supportsRelations) {
+          throw new Error(`Relation path navigation requires a collection that supports relations, but '${currentCollection.slug}' uses driver '${currentCollection.driver}'`);
         }
         const resolvedRelations = resolveCollectionRelations(currentCollection);
-        const relation = resolvedRelations[relationKey];
+        const relation = findRelation(resolvedRelations, relationKey);
         if (!relation) {
           throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'`);
         }
@@ -3201,10 +3400,16 @@
       return currentCollection;
     }
     getCollections() {
-      return Array.from(this.collectionsByTableName.values());
+      if (!this.cachedCollectionsList) {
+        this.cachedCollectionsList = Array.from(this.collectionsByTableName.values());
+      }
+      return this.cachedCollectionsList;
     }
     getRawCollections() {
-      return Array.from(this.rawCollectionsByTableName.values());
+      if (!this.cachedRawCollectionsList) {
+        this.cachedRawCollectionsList = Array.from(this.rawCollectionsByTableName.values());
+      }
+      return this.cachedRawCollectionsList;
     }
     /**
      * Resolves a multi-segment path like "products/123/locales" and returns
@@ -3260,24 +3465,62 @@
       "lte": "<=",
       "in": "in",
       "nin": "not-in",
+      "not-in": "not-in",
       "cs": "array-contains",
-      "csa": "array-contains-any"
+      "csa": "array-contains-any",
+      "==": "==",
+      "!=": "!=",
+      ">": ">",
+      ">=": ">=",
+      "<": "<",
+      "<=": "<=",
+      "array-contains": "array-contains",
+      "array-contains-any": "array-contains-any"
     };
     const filter = {};
     for (const [field, rawValue] of Object.entries(where)) {
-      const dotIndex = rawValue.indexOf(".");
-      if (dotIndex === -1) continue;
-      const op = rawValue.substring(0, dotIndex);
-      let value = rawValue.substring(dotIndex + 1);
-      if (typeof value === "string" && value.startsWith("(") && value.endsWith(")")) {
-        value = value.slice(1, -1).split(",").map((v) => v.trim());
+      if (rawValue === null) {
+        filter[field] = ["==", null];
+        continue;
+      }
+      if (typeof rawValue === "boolean") {
+        filter[field] = ["==", rawValue];
+        continue;
+      }
+      if (typeof rawValue === "number") {
+        filter[field] = ["==", rawValue];
+        continue;
       }
-      if (typeof value === "string" && !isNaN(Number(value)) && value.trim() !== "") {
-        value = Number(value);
+      if (Array.isArray(rawValue) && rawValue.length === 2) {
+        const [rawOp, val] = rawValue;
+        const mappedOp = operatorMap[rawOp] ?? "==";
+        filter[field] = [mappedOp, val];
+        continue;
       }
-      const mappedOp = operatorMap[op];
-      if (mappedOp) {
-        filter[field] = [mappedOp, value];
+      if (typeof rawValue === "string") {
+        const dotIndex = rawValue.indexOf(".");
+        if (dotIndex === -1) {
+          filter[field] = ["==", rawValue];
+          continue;
+        }
+        const op = rawValue.substring(0, dotIndex);
+        let value = rawValue.substring(dotIndex + 1);
+        if (typeof value === "string" && value.startsWith("(") && value.endsWith(")")) {
+          value = value.slice(1, -1).split(",").map((v) => v.trim());
+        }
+        if (value === "null") {
+          value = null;
+        } else if (value === "true") {
+          value = true;
+        } else if (value === "false") {
+          value = false;
+        } else if (typeof value === "string" && !isNaN(Number(value)) && value.trim() !== "") {
+          value = Number(value);
+        }
+        const mappedOp = operatorMap[op];
+        if (mappedOp) {
+          filter[field] = [mappedOp, value];
+        }
       }
     }
     return Object.keys(filter).length > 0 ? filter : void 0;
@@ -3296,7 +3539,7 @@
         const entities = await driver.fetchCollection({
           path: slug,
           limit: params?.limit,
-          startAfter: params?.offset,
+          offset: params?.offset,
           filter: convertWhereToFilter(params?.where),
           orderBy: orderParsed?.[0],
           order: orderParsed?.[1],
@@ -3358,7 +3601,7 @@
         return driver.listenCollection({
           path: slug,
           limit: params?.limit,
-          startAfter: params?.offset,
+          offset: params?.offset,
           filter: convertWhereToFilter(params?.where),
           orderBy: orderParsed?.[0],
           order: orderParsed?.[1],
@@ -3405,7 +3648,8 @@
         if (prop === "collection") return getAccessor;
         if (typeof prop === "symbol") return void 0;
         if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return void 0;
-        return getAccessor(prop);
+        const slug = toSnakeCase(prop);
+        return getAccessor(slug);
       }
     });
   }
@@ -3463,7 +3707,7 @@
      * Build relation-based conditions for different relation types
      */
     static buildRelationConditions(relation, parentEntityId, targetTable, parentTable, parentIdColumn, targetIdColumn, registry) {
-      console.debug(`🔍 [buildRelationConditions] Building conditions for relation:`, {
+      console.debug("🔍 [buildRelationConditions] Building conditions for relation:", {
         relationName: relation.relationName,
         cardinality: relation.cardinality,
         direction: relation.direction,
@@ -3475,7 +3719,7 @@
       const joinConditions = [];
       const whereConditions = [];
       if (relation.joinPath && relation.joinPath.length > 0) {
-        console.debug(`🔍 [buildRelationConditions] Using joinPath logic`);
+        console.debug("🔍 [buildRelationConditions] Using joinPath logic");
         const {
           joins,
           finalCondition
@@ -3483,37 +3727,37 @@
         joinConditions.push(...joins);
         whereConditions.push(finalCondition);
       } else if (relation.through && relation.cardinality === "many" && relation.direction === "owning") {
-        console.debug(`🔍 [buildRelationConditions] Using owning many-to-many with explicit through`);
+        console.debug("🔍 [buildRelationConditions] Using owning many-to-many with explicit through");
         const junctionResult = this.buildJunctionTableConditions(relation.through, targetIdColumn, parentEntityId, registry);
         joinConditions.push(junctionResult.join);
         whereConditions.push(junctionResult.condition);
       } else if (relation.through && relation.cardinality === "many" && relation.direction === "inverse") {
-        console.debug(`🔍 [buildRelationConditions] Using inverse many-to-many with explicit through`);
+        console.debug("🔍 [buildRelationConditions] Using inverse many-to-many with explicit through");
         const junctionResult = this.buildInverseJunctionTableConditions(relation.through, targetIdColumn, parentEntityId, registry);
         joinConditions.push(junctionResult.join);
         whereConditions.push(junctionResult.condition);
       } else if (relation.cardinality === "many" && relation.direction === "inverse" && !relation.through) {
-        console.debug(`🔍 [buildRelationConditions] Handling inverse many relationship without explicit through`);
+        console.debug("🔍 [buildRelationConditions] Handling inverse many relationship without explicit through");
         const junctionInfo = this.findCorrespondingJunctionTable(relation, registry);
         if (junctionInfo) {
-          console.debug(`🔍 [buildRelationConditions] Found junction info for inverse many-to-many, building junction conditions`);
+          console.debug("🔍 [buildRelationConditions] Found junction info for inverse many-to-many, building junction conditions");
           const junctionResult = this.buildInverseJunctionTableConditions(junctionInfo, targetIdColumn, parentEntityId, registry);
           joinConditions.push(junctionResult.join);
           whereConditions.push(junctionResult.condition);
         } else if (relation.foreignKeyOnTarget) {
-          console.debug(`🔍 [buildRelationConditions] No junction table found, treating as inverse one-to-many with foreign key on target`);
+          console.debug("🔍 [buildRelationConditions] No junction table found, treating as inverse one-to-many with foreign key on target");
           const simpleCondition = this.buildSimpleRelationCondition(relation, targetTable, parentTable, parentEntityId);
           whereConditions.push(simpleCondition);
         } else {
-          console.error(`🔍 [buildRelationConditions] Failed to find junction table info and no foreign key specified`);
+          console.error("🔍 [buildRelationConditions] Failed to find junction table info and no foreign key specified");
           throw new Error(`Cannot resolve inverse many relation '${relation.relationName}'. Either specify 'through' property, ensure corresponding owning relation exists with junction table configuration, or specify 'foreignKeyOnTarget' for one-to-many relationships.`);
         }
       } else {
-        console.debug(`🔍 [buildRelationConditions] Using simple relation logic - THIS IS WHERE THE ERROR MIGHT OCCUR`);
+        console.debug("🔍 [buildRelationConditions] Using simple relation logic - THIS IS WHERE THE ERROR MIGHT OCCUR");
         const simpleCondition = this.buildSimpleRelationCondition(relation, targetTable, parentTable, parentEntityId);
         whereConditions.push(simpleCondition);
       }
-      console.debug(`🔍 [buildRelationConditions] Final result:`, {
+      console.debug("🔍 [buildRelationConditions] Final result:", {
         joinConditionsCount: joinConditions.length,
         whereConditionsCount: whereConditions.length
       });
@@ -3764,7 +4008,8 @@
     static buildSearchConditions(searchString, properties, table) {
       const searchConditions = [];
       for (const [key, prop] of Object.entries(properties)) {
-        if (prop.type === "string" && !prop.enum && prop.isId !== "uuid") {
+        const p = prop;
+        if (p.type === "string" && !p.enum && p.isId !== "uuid") {
           const fieldColumn = table[key];
           if (fieldColumn) {
             searchConditions.push(drizzleOrm.ilike(fieldColumn, `%${searchString}%`));
@@ -3927,29 +4172,29 @@
       try {
         console.debug(`🔍 [findCorrespondingJunctionTable] Looking for junction table for inverse relation '${relation.relationName}' with inverseRelationName '${relation.inverseRelationName}'`);
         if (!relation.inverseRelationName) {
-          console.debug(`🔍 [findCorrespondingJunctionTable] No inverseRelationName specified`);
+          console.debug("🔍 [findCorrespondingJunctionTable] No inverseRelationName specified");
           return null;
         }
         const targetCollection = relation.target();
         console.debug(`🔍 [findCorrespondingJunctionTable] Target collection: ${targetCollection.slug}`);
         const targetCollectionRelations = resolveCollectionRelations(targetCollection);
-        console.debug(`🔍 [findCorrespondingJunctionTable] Target collection relations:`, Object.keys(targetCollectionRelations));
+        console.debug("🔍 [findCorrespondingJunctionTable] Target collection relations:", Object.keys(targetCollectionRelations));
         const correspondingRelation = targetCollectionRelations[relation.inverseRelationName];
         if (!correspondingRelation) {
           console.debug(`🔍 [findCorrespondingJunctionTable] No relation found with key '${relation.inverseRelationName}' on target collection`);
           return null;
         }
-        console.debug(`🔍 [findCorrespondingJunctionTable] Found relation:`, {
+        console.debug("🔍 [findCorrespondingJunctionTable] Found relation:", {
           relationName: correspondingRelation.relationName,
           cardinality: correspondingRelation.cardinality,
           direction: correspondingRelation.direction,
           hasThrough: !!correspondingRelation.through
         });
         if (correspondingRelation.cardinality !== "many" || correspondingRelation.direction !== "owning" || !correspondingRelation.through) {
-          console.debug(`🔍 [findCorrespondingJunctionTable] Relation is not an owning many-to-many with junction table`);
+          console.debug("🔍 [findCorrespondingJunctionTable] Relation is not an owning many-to-many with junction table");
           return null;
         }
-        console.debug(`🔍 [findCorrespondingJunctionTable] Found matching owning relation with junction table!`);
+        console.debug("🔍 [findCorrespondingJunctionTable] Found matching owning relation with junction table!");
         const through = correspondingRelation.through;
         const result = {
           table: through.table,
@@ -3958,7 +4203,7 @@
           targetColumn: through.sourceColumn
           // Swapped for inverse relation
         };
-        console.debug(`🔍 [findCorrespondingJunctionTable] Returning junction info:`, result);
+        console.debug("🔍 [findCorrespondingJunctionTable] Returning junction info:", result);
         return result;
       } catch (error) {
         console.error(`🔍 [findCorrespondingJunctionTable] Error finding corresponding junction table for relation '${relation.relationName}':`, error);
@@ -3967,10 +4212,19 @@
     }
   }
   const PostgresConditionBuilder = DrizzleConditionBuilder;
+  function getColumnMeta(col) {
+    const raw = col;
+    return {
+      columnType: typeof raw.columnType === "string" ? raw.columnType : void 0,
+      dataType: typeof raw.dataType === "string" ? raw.dataType : void 0,
+      primary: typeof raw.primary === "boolean" ? raw.primary : void 0
+    };
+  }
   function getCollectionByPath(collectionPath, registry) {
     const collection = registry.getCollectionByPath(collectionPath);
     if (!collection) {
-      throw new Error(`Collection not found: ${collectionPath}`);
+      const registered = registry.getCollections().map((c) => c.slug).join(", ");
+      throw new Error(`Collection not found: ${collectionPath}. Registered collections: [${registered}]`);
     }
     return collection;
   }
@@ -3987,7 +4241,8 @@
     if (collection.properties) {
       const idProps = Object.entries(collection.properties).filter(([_, prop]) => "isId" in prop && Boolean(prop.isId)).map(([key, prop]) => ({
         fieldName: key,
-        type: prop.type === "number" ? "number" : "string"
+        type: prop.type === "number" ? "number" : "string",
+        isUUID: prop.isId === "uuid"
       }));
       if (idProps.length > 0) {
         return idProps;
@@ -3997,19 +4252,25 @@
     for (const [key, colRaw] of Object.entries(table)) {
       const col = colRaw;
       if (col && typeof col === "object" && "primary" in col && col.primary) {
-        const type = col.dataType === "number" || col.columnType === "PgSerial" || col.columnType === "PgInteger" ? "number" : "string";
+        const meta = getColumnMeta(col);
+        const type = col.dataType === "number" || meta.columnType === "PgSerial" || meta.columnType === "PgInteger" ? "number" : "string";
+        const isUUID = meta.columnType === "PgUUID";
         keys2.push({
           fieldName: key,
-          type
+          type,
+          isUUID
         });
       }
     }
     if (keys2.length === 0 && "id" in table) {
       const idCol = table["id"];
-      const type = idCol.dataType === "number" || idCol.columnType === "PgSerial" || idCol.columnType === "PgInteger" ? "number" : "string";
+      const idMeta = getColumnMeta(idCol);
+      const type = idCol.dataType === "number" || idMeta.columnType === "PgSerial" || idMeta.columnType === "PgInteger" ? "number" : "string";
+      const isUUID = idMeta.columnType === "PgUUID";
       keys2.push({
         fieldName: "id",
-        type
+        type,
+        isUUID
       });
     }
     return keys2;
@@ -4021,7 +4282,7 @@
     }
     if (primaryKeys.length === 1) {
       const pk = primaryKeys[0];
-      if (pk.type === "number") {
+      if (pk.type === "number" && !pk.isUUID) {
         const parsed = typeof idValue === "number" ? idValue : parseInt(String(idValue), 10);
         if (isNaN(parsed)) {
           throw new Error(`Invalid numeric ID: ${idValue}`);
@@ -4039,7 +4300,7 @@
     for (let i = 0; i < primaryKeys.length; i++) {
       const pk = primaryKeys[i];
       const val = parts[i];
-      if (pk.type === "number") {
+      if (pk.type === "number" && !pk.isUUID) {
         const parsed = parseInt(val, 10);
         if (isNaN(parsed)) {
           throw new Error(`Invalid numeric ID component: ${val}`);
@@ -4098,28 +4359,37 @@
     return obj;
   }
   function serializeDataToServer(entity, properties, collection, registry) {
-    if (!entity || !properties) return entity;
+    if (!entity || !properties) return {
+      scalarData: entity ?? {},
+      inverseRelationUpdates: [],
+      joinPathRelationUpdates: []
+    };
     const result = {};
     const resolvedRelations = collection ? resolveCollectionRelations(collection) : {};
     const inverseRelationUpdates = [];
     const joinPathRelationUpdates = [];
+    const foreignKeys = /* @__PURE__ */ new Set();
+    Object.values(resolvedRelations).forEach((relation) => {
+      if (relation.localKey) foreignKeys.add(relation.localKey);
+    });
     for (const [key, value] of Object.entries(entity)) {
       const property = properties[key];
+      const effectiveValue = foreignKeys.has(key) && value === "" ? null : value;
       if (!property) {
-        result[key] = value;
+        result[key] = effectiveValue;
         continue;
       }
       if (property.type === "relation" && collection) {
-        const relation = resolvedRelations[key];
+        const relation = findRelation(resolvedRelations, key);
         if (relation) {
           if (relation.direction === "owning" && relation.localKey) {
-            const serializedValue = serializePropertyToServer(value, property);
-            if (serializedValue !== null && serializedValue !== void 0) {
+            const serializedValue = serializePropertyToServer(effectiveValue, property);
+            if (serializedValue !== void 0) {
               result[relation.localKey] = serializedValue;
             }
             continue;
           } else if (relation.direction === "inverse" && relation.foreignKeyOnTarget) {
-            const serializedValue = serializePropertyToServer(value, property);
+            const serializedValue = serializePropertyToServer(effectiveValue, property);
             const pks = getPrimaryKeys(collection, registry);
             inverseRelationUpdates.push({
               relationKey: key,
@@ -4129,7 +4399,7 @@
             });
             continue;
           } else if (relation.direction === "inverse" && relation.joinPath && relation.joinPath.length > 0) {
-            const serializedValue = serializePropertyToServer(value, property);
+            const serializedValue = serializePropertyToServer(effectiveValue, property);
             if (relation.cardinality === "one") {
               joinPathRelationUpdates.push({
                 relationKey: key,
@@ -4147,7 +4417,7 @@
             }
             continue;
           } else if (relation.cardinality === "one" && relation.direction === "owning" && relation.joinPath && relation.joinPath.length > 0) {
-            const serializedValue = serializePropertyToServer(value, property);
+            const serializedValue = serializePropertyToServer(effectiveValue, property);
             joinPathRelationUpdates.push({
               relationKey: key,
               relation,
@@ -4157,15 +4427,13 @@
           }
         }
       }
-      result[key] = serializePropertyToServer(value, property);
+      result[key] = serializePropertyToServer(effectiveValue, property);
     }
-    if (inverseRelationUpdates.length > 0) {
-      result.__inverseRelationUpdates = inverseRelationUpdates;
-    }
-    if (joinPathRelationUpdates.length > 0) {
-      result.__joinPathRelationUpdates = joinPathRelationUpdates;
-    }
-    return result;
+    return {
+      scalarData: result,
+      inverseRelationUpdates,
+      joinPathRelationUpdates
+    };
   }
   function serializePropertyToServer(value, property) {
     if (value === null || value === void 0) {
@@ -4179,10 +4447,28 @@
         } else if (typeof value === "object" && value !== null && "id" in value) {
           return value.id;
         }
+        if (value === "") return null;
         return value;
       case "array":
-        if (Array.isArray(value) && property.of) {
-          return value.map((item) => serializePropertyToServer(item, property.of));
+        if (Array.isArray(value)) {
+          if (property.of) {
+            return value.map((item) => serializePropertyToServer(item, property.of));
+          } else if (property.oneOf) {
+            const typeField = property.oneOf.typeField ?? DEFAULT_ONE_OF_TYPE;
+            const valueField = property.oneOf.valueField ?? DEFAULT_ONE_OF_VALUE;
+            return value.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]: serializePropertyToServer(rec[valueField], childProperty)
+              };
+            });
+          }
         }
         return value;
       case "map":
@@ -4206,38 +4492,20 @@
   async function parseDataFromServer(data, collection, db, registry) {
     const properties = collection.properties;
     if (!data || !properties) return data;
-    const result = {};
     const resolvedRelations = resolveCollectionRelations(collection);
-    const internalFKColumns = /* @__PURE__ */ new Set();
-    Object.values(resolvedRelations).forEach((relation) => {
-      if (relation.localKey && !properties[relation.localKey]) {
-        internalFKColumns.add(relation.localKey);
-      }
+    const result = normalizeScalarValues(data, properties, collection, resolvedRelations, {
+      skipRelations: false
     });
-    for (const [key, value] of Object.entries(data)) {
-      if (internalFKColumns.has(key)) {
-        continue;
-      }
-      const property = properties[key];
-      if (!property) {
-        continue;
-      }
-      result[key] = parsePropertyFromServer(value, property, collection, key);
-    }
     for (const [propKey, property] of Object.entries(properties)) {
       if (property.type === "relation" && !(propKey in result)) {
-        const relation = resolvedRelations[propKey];
+        const relation = findRelation(resolvedRelations, propKey);
         if (relation) {
           if (relation.direction === "owning" && relation.localKey && relation.localKey in data) {
             const fkValue = data[relation.localKey];
             if (fkValue !== null && fkValue !== void 0) {
               try {
                 const targetCollection = relation.target();
-                result[propKey] = {
-                  id: fkValue.toString(),
-                  path: targetCollection.slug,
-                  __type: "relation"
-                };
+                result[propKey] = createRelationRef(fkValue.toString(), targetCollection.slug);
               } catch (e) {
                 console.warn(`Could not resolve target collection for relation property: ${propKey}`, e);
               }
@@ -4256,18 +4524,10 @@
                     if (relation.cardinality === "one") {
                       const targetPks = getPrimaryKeys(targetCollection, registry);
                       const relatedEntity = relatedEntities[0];
-                      result[propKey] = {
-                        id: buildCompositeId(relatedEntity, targetPks),
-                        path: targetCollection.slug,
-                        __type: "relation"
-                      };
+                      result[propKey] = createRelationRef(buildCompositeId(relatedEntity, targetPks), targetCollection.slug);
                     } else {
                       const targetPks = getPrimaryKeys(targetCollection, registry);
-                      result[propKey] = relatedEntities.map((entity) => ({
-                        id: buildCompositeId(entity, targetPks),
-                        path: targetCollection.slug,
-                        __type: "relation"
-                      }));
+                      result[propKey] = relatedEntities.map((entity) => createRelationRef(buildCompositeId(entity, targetPks), targetCollection.slug));
                     }
                   }
                 }
@@ -4328,19 +4588,11 @@
                   if (relation.cardinality === "one") {
                     const joinResult = joinResults[0];
                     const targetEntity = joinResult[targetTableName] || joinResult;
-                    result[propKey] = {
-                      id: buildCompositeId(targetEntity, targetPks),
-                      path: targetCollection.slug,
-                      __type: "relation"
-                    };
+                    result[propKey] = createRelationRef(buildCompositeId(targetEntity, targetPks), targetCollection.slug);
                   } else {
                     result[propKey] = joinResults.map((joinResult) => {
                       const targetEntity = joinResult[targetTableName] || joinResult;
-                      return {
-                        id: buildCompositeId(targetEntity, targetPks),
-                        path: targetCollection.slug,
-                        __type: "relation"
-                      };
+                      return createRelationRef(buildCompositeId(targetEntity, targetPks), targetCollection.slug);
                     });
                   }
                 }
@@ -4364,7 +4616,7 @@
           let relationDef = property.relation;
           if (!relationDef && propertyKey) {
             const resolvedRelations = resolveCollectionRelations(collection);
-            relationDef = resolvedRelations[propertyKey];
+            relationDef = findRelation(resolvedRelations, propertyKey);
           }
           if (!relationDef) {
             relationDef = collection.relations?.find((rel) => rel.relationName === property.relationName);
@@ -4375,11 +4627,7 @@
           }
           try {
             const targetCollection = relationDef.target();
-            return {
-              id: value.toString(),
-              path: targetCollection.slug,
-              __type: "relation"
-            };
+            return createRelationRef(value.toString(), targetCollection.slug);
           } catch (e) {
             console.warn(`Could not resolve target collection for relation property: ${propertyKey || "unknown"}`, e);
             return value;
@@ -4387,8 +4635,25 @@
         }
         return value;
       case "array":
-        if (Array.isArray(value) && property.of) {
-          return value.map((item) => parsePropertyFromServer(item, property.of, collection));
+        if (Array.isArray(value)) {
+          if (property.of) {
+            return value.map((item) => parsePropertyFromServer(item, property.of, collection));
+          } else if (property.oneOf) {
+            const typeField = property.oneOf.typeField ?? DEFAULT_ONE_OF_TYPE;
+            const valueField = property.oneOf.valueField ?? DEFAULT_ONE_OF_VALUE;
+            return value.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]: parsePropertyFromServer(rec[valueField], childProperty, collection)
+              };
+            });
+          }
         }
         return value;
       case "map":
@@ -4433,11 +4698,8 @@
         return value;
     }
   }
-  function normalizeDbValues(data, collection) {
-    const properties = collection.properties;
-    if (!data || !properties) return data;
+  function normalizeScalarValues(data, properties, collection, resolvedRelations, options) {
     const result = {};
-    const resolvedRelations = resolveCollectionRelations(collection);
     const internalFKColumns = /* @__PURE__ */ new Set();
     Object.values(resolvedRelations).forEach((relation) => {
       if (relation.localKey && !properties[relation.localKey]) {
@@ -4445,14 +4707,25 @@
       }
     });
     for (const [key, value] of Object.entries(data)) {
-      if (internalFKColumns.has(key)) continue;
+      if (internalFKColumns.has(key)) {
+        result[key] = value === null ? null : typeof value === "number" ? value : String(value);
+        continue;
+      }
       const property = properties[key];
       if (!property) continue;
-      if (property.type === "relation") continue;
+      if (options.skipRelations && property.type === "relation") continue;
       result[key] = parsePropertyFromServer(value, property, collection, key);
     }
     return result;
   }
+  function normalizeDbValues(data, collection) {
+    const properties = collection.properties;
+    if (!data || !properties) return data;
+    const resolvedRelations = resolveCollectionRelations(collection);
+    return normalizeScalarValues(data, properties, collection, resolvedRelations, {
+      skipRelations: true
+    });
+  }
   class RelationService {
     constructor(db, registry) {
       this.db = db;
@@ -4464,9 +4737,10 @@
     async fetchRelatedEntities(parentCollectionPath, parentEntityId, relationKey, options = {}) {
       const parentCollection = getCollectionByPath(parentCollectionPath, this.registry);
       const resolvedRelations = resolveCollectionRelations(parentCollection);
-      const relation = resolvedRelations[relationKey];
+      const relation = findRelation(resolvedRelations, relationKey);
       if (!relation) {
-        throw new Error(`Relation '${relationKey}' not found in collection '${parentCollectionPath}'`);
+        const available = Object.keys(resolvedRelations).join(", ") || "(none)";
+        throw new Error(`Relation '${relationKey}' not found in collection '${parentCollectionPath}'. Available relations: [${available}]`);
       }
       return this.fetchEntitiesUsingJoins(parentCollection, parentEntityId, relation, options);
     }
@@ -4566,8 +4840,11 @@
     async countRelatedEntities(parentCollectionPath, parentEntityId, relationKey, options = {}) {
       const parentCollection = getCollectionByPath(parentCollectionPath, this.registry);
       const resolvedRelations = resolveCollectionRelations(parentCollection);
-      const relation = resolvedRelations[relationKey];
-      if (!relation) throw new Error(`Relation '${relationKey}' not found in collection '${parentCollectionPath}'`);
+      const relation = findRelation(resolvedRelations, relationKey);
+      if (!relation) {
+        const available = Object.keys(resolvedRelations).join(", ") || "(none)";
+        throw new Error(`Relation '${relationKey}' not found in collection '${parentCollectionPath}'. Available relations: [${available}]`);
+      }
       const targetCollection = relation.target();
       const targetTable = getTableForCollection(targetCollection, this.registry);
       const targetPks = getPrimaryKeys(targetCollection, this.registry);
@@ -4632,16 +4909,59 @@
         const results2 = await query2;
         const targetTableName = relation.joinPath[relation.joinPath.length - 1].table;
         const resultMap2 = /* @__PURE__ */ new Map();
-        results2.forEach((row) => {
+        for (const row of results2) {
           const parentEntity = row[getTableName(parentCollection)] || row;
           const targetEntity = row[targetTableName] || row;
           const parentId = parentEntity[parentIdInfo.fieldName];
-          resultMap2.set(parentId, {
+          const parsedValues = await parseDataFromServer(targetEntity, targetCollection);
+          resultMap2.set(String(parentId), {
             id: String(targetEntity[targetIdInfo.fieldName]),
             path: targetCollection.slug,
-            values: targetEntity
+            values: parsedValues
           });
-        });
+        }
+        return resultMap2;
+      }
+      if (relation.direction === "owning" && relation.localKey) {
+        const localKeyCol = parentTable[relation.localKey];
+        if (!localKeyCol) {
+          throw new Error(`Local key column '${relation.localKey}' not found in parent table`);
+        }
+        const fkRows = await this.db.select({
+          parentId: parentIdCol,
+          fkValue: localKeyCol
+        }).from(parentTable).where(drizzleOrm.inArray(parentIdCol, parsedParentIds));
+        const parentToFk = /* @__PURE__ */ new Map();
+        const uniqueFkValues = [];
+        const seenFks = /* @__PURE__ */ new Set();
+        for (const row of fkRows) {
+          if (row.fkValue == null) continue;
+          parentToFk.set(String(row.parentId), row.fkValue);
+          const fkStr = String(row.fkValue);
+          if (!seenFks.has(fkStr)) {
+            seenFks.add(fkStr);
+            uniqueFkValues.push(row.fkValue);
+          }
+        }
+        if (uniqueFkValues.length === 0) return /* @__PURE__ */ new Map();
+        const targetResults = await this.db.select().from(targetTable).where(drizzleOrm.inArray(targetIdField, uniqueFkValues));
+        const targetById = /* @__PURE__ */ new Map();
+        for (const row of targetResults) {
+          const tid = String(row[targetIdInfo.fieldName]);
+          targetById.set(tid, row);
+        }
+        const resultMap2 = /* @__PURE__ */ new Map();
+        for (const [parentIdStr, fkValue] of parentToFk) {
+          const targetEntity = targetById.get(String(fkValue));
+          if (targetEntity) {
+            const parsedValues = await parseDataFromServer(targetEntity, targetCollection);
+            resultMap2.set(parentIdStr, {
+              id: String(targetEntity[targetIdInfo.fieldName]),
+              path: targetCollection.slug,
+              values: parsedValues
+            });
+          }
+        }
         return resultMap2;
       }
       let query = this.db.select().from(targetTable).$dynamic();
@@ -4659,7 +4979,8 @@
       );
       const results = await query;
       const resultMap = /* @__PURE__ */ new Map();
-      results.forEach((row) => {
+      const parentIdSet = new Set(parsedParentIds.map(String));
+      for (const row of results) {
         const targetEntity = row[getTableName(targetCollection)] || row;
         let parentId;
         if (relation.direction === "inverse" && relation.foreignKeyOnTarget) {
@@ -4667,22 +4988,133 @@
         } else if (relation.direction === "inverse" && relation.cardinality === "one" && relation.inverseRelationName) {
           const inferredForeignKeyName = `${relation.inverseRelationName}_id`;
           parentId = targetEntity[inferredForeignKeyName];
-        } else if (relation.direction === "owning" && relation.localKey) {
-          for (const parsedParentId of parsedParentIds) {
-            if (!resultMap.has(parsedParentId)) {
-              parentId = parsedParentId;
-              break;
-            }
-          }
         }
-        if (parentId !== void 0 && parsedParentIds.includes(parentId)) {
-          resultMap.set(parentId, {
+        if (parentId !== void 0 && parentIdSet.has(String(parentId))) {
+          const parsedValues = await parseDataFromServer(targetEntity, targetCollection);
+          resultMap.set(String(parentId), {
             id: String(targetEntity[targetIdInfo.fieldName]),
             path: targetCollection.slug,
-            values: targetEntity
+            values: parsedValues
           });
         }
-      });
+      }
+      return resultMap;
+    }
+    /**
+     * Batch fetch many-cardinality related entities for multiple parent entities.
+     * Returns a Map<parentId, Entity[]> instead of Map<parentId, Entity>.
+     * Uses a single SQL query with IN clause to avoid N+1.
+     */
+    async batchFetchRelatedEntitiesMany(parentCollectionPath, parentEntityIds, _relationKey, relation) {
+      if (parentEntityIds.length === 0) return /* @__PURE__ */ new Map();
+      const parentCollection = getCollectionByPath(parentCollectionPath, this.registry);
+      const targetCollection = relation.target();
+      const targetTable = getTableForCollection(targetCollection, this.registry);
+      const targetPks = getPrimaryKeys(targetCollection, this.registry);
+      const targetIdInfo = targetPks[0];
+      const targetIdField = targetTable[targetIdInfo.fieldName];
+      const parentPks = getPrimaryKeys(parentCollection, this.registry);
+      const parentIdInfo = parentPks[0];
+      const parentTable = this.registry.getTable(getTableName(parentCollection));
+      if (!parentTable) throw new Error("Parent table not found");
+      const parentIdCol = parentTable[parentIdInfo.fieldName];
+      const parsedParentIds = parentEntityIds.map((id) => parseIdValues(id, parentPks)[parentIdInfo.fieldName]);
+      if (relation.joinPath && relation.joinPath.length > 0) {
+        let query2 = this.db.select().from(parentTable).$dynamic();
+        let currentTable = parentTable;
+        for (const join of relation.joinPath) {
+          const joinTable = this.registry.getTable(join.table);
+          if (!joinTable) throw new Error(`Join table not found: ${join.table}`);
+          const fromColumn = Array.isArray(join.on.from) ? join.on.from[0] : join.on.from;
+          const toColumn = Array.isArray(join.on.to) ? join.on.to[0] : join.on.to;
+          const fromColName = fromColumn.split(".").pop();
+          const toColName = toColumn.split(".").pop();
+          const fromCol = currentTable[fromColName];
+          const toCol = joinTable[toColName];
+          if (!fromCol || !toCol) throw new Error(`Join columns not found: ${fromColumn} -> ${toColumn}`);
+          query2 = query2.innerJoin(joinTable, drizzleOrm.eq(fromCol, toCol));
+          currentTable = joinTable;
+        }
+        const parentIdField = parentTable[getPrimaryKeys(parentCollection, this.registry)[0].fieldName];
+        query2 = query2.where(drizzleOrm.inArray(parentIdField, parsedParentIds));
+        const results2 = await query2;
+        const targetTableName = relation.joinPath[relation.joinPath.length - 1].table;
+        const resultMap2 = /* @__PURE__ */ new Map();
+        for (const row of results2) {
+          const parentEntity = row[getTableName(parentCollection)] || row;
+          const targetEntity = row[targetTableName] || row;
+          const parentId = String(parentEntity[parentIdInfo.fieldName]);
+          const parsedValues = await parseDataFromServer(targetEntity, targetCollection);
+          const arr = resultMap2.get(parentId) || [];
+          arr.push({
+            id: String(targetEntity[targetIdInfo.fieldName]),
+            path: targetCollection.slug,
+            values: parsedValues
+          });
+          resultMap2.set(parentId, arr);
+        }
+        return resultMap2;
+      }
+      if (relation.through && relation.cardinality === "many" && relation.direction === "owning") {
+        const junctionTable = this.registry.getTable(relation.through.table);
+        if (!junctionTable) {
+          console.warn(`[batchFetchRelatedEntitiesMany] Junction table '${relation.through.table}' not found`);
+          return /* @__PURE__ */ new Map();
+        }
+        const sourceJunctionCol = junctionTable[relation.through.sourceColumn];
+        const targetJunctionCol = junctionTable[relation.through.targetColumn];
+        if (!sourceJunctionCol || !targetJunctionCol) {
+          console.warn(`[batchFetchRelatedEntitiesMany] Junction columns not found in '${relation.through.table}'`);
+          return /* @__PURE__ */ new Map();
+        }
+        const query2 = this.db.select().from(junctionTable).innerJoin(targetTable, drizzleOrm.eq(targetJunctionCol, targetIdField)).where(drizzleOrm.inArray(sourceJunctionCol, parsedParentIds));
+        const results2 = await query2;
+        const resultMap2 = /* @__PURE__ */ new Map();
+        const targetTableName = getTableName(targetCollection);
+        for (const row of results2) {
+          const junctionData = row[relation.through.table] || row;
+          const targetData = row[targetTableName] || row;
+          const parentId = String(junctionData[relation.through.sourceColumn]);
+          const parsedValues = await parseDataFromServer(targetData, targetCollection);
+          const arr = resultMap2.get(parentId) || [];
+          arr.push({
+            id: String(targetData[targetIdInfo.fieldName]),
+            path: targetCollection.slug,
+            values: parsedValues
+          });
+          resultMap2.set(parentId, arr);
+        }
+        return resultMap2;
+      }
+      let query = this.db.select().from(targetTable).$dynamic();
+      query = DrizzleConditionBuilder.buildRelationQuery(query, relation, parsedParentIds, targetTable, parentTable, parentIdCol, targetIdField, this.registry, []);
+      const results = await query;
+      const resultMap = /* @__PURE__ */ new Map();
+      const parentIdSet = new Set(parsedParentIds.map(String));
+      for (const row of results) {
+        const targetEntity = row[getTableName(targetCollection)] || row;
+        let parentId;
+        if (relation.through && relation.direction === "inverse") {
+          const junctionData = row[relation.through.table] || row;
+          parentId = junctionData[relation.through.targetColumn];
+        } else if (relation.direction === "inverse" && relation.foreignKeyOnTarget) {
+          parentId = targetEntity[relation.foreignKeyOnTarget];
+        } else if (relation.direction === "inverse" && relation.inverseRelationName) {
+          const inferredForeignKeyName = `${relation.inverseRelationName}_id`;
+          parentId = targetEntity[inferredForeignKeyName];
+        }
+        if (parentId !== void 0 && parentIdSet.has(String(parentId))) {
+          const parsedValues = await parseDataFromServer(targetEntity, targetCollection);
+          const key = String(parentId);
+          const arr = resultMap.get(key) || [];
+          arr.push({
+            id: String(targetEntity[targetIdInfo.fieldName]),
+            path: targetCollection.slug,
+            values: parsedValues
+          });
+          resultMap.set(key, arr);
+        }
+      }
       return resultMap;
     }
     /**
@@ -4691,7 +5123,7 @@
     async updateRelationsUsingJoins(tx, collection, entityId, relationValues) {
       const resolvedRelations = resolveCollectionRelations(collection);
       for (const [key, value] of Object.entries(relationValues)) {
-        const relation = resolvedRelations[key];
+        const relation = findRelation(resolvedRelations, key);
         if (!relation || relation.cardinality !== "many") continue;
         const targetEntityIds = value && Array.isArray(value) ? value.map((rel) => rel.id) : [];
         const targetCollection = relation.target();
@@ -4775,6 +5207,8 @@
               await tx.insert(junctionTable).values(newLinks);
             }
           }
+        } else if (relation.through && relation.cardinality === "many" && relation.direction === "inverse") {
+          console.warn(`[updateRelationsUsingJoins] Inverse M2M relation '${key}' in collection '${collection.slug}' should be saved from the owning side. Skipping.`);
         } else if (relation.cardinality === "many" && relation.direction === "inverse" && relation.foreignKeyOnTarget) {
           const targetTable = getTableForCollection(targetCollection, this.registry);
           const targetPks = getPrimaryKeys(targetCollection, this.registry);
@@ -5152,6 +5586,20 @@
     // =============================================================
     // DRIZZLE QUERY HELPERS
     // =============================================================
+    /**
+     * Resolves the correct Drizzle column for sorting.
+     * Automatically maps owning relation property keys to their underlying foreign key column.
+     */
+    resolveOrderByField(table, orderBy, collection) {
+      let orderByField = table[orderBy];
+      if (!orderByField && collection) {
+        const property = collection.properties[orderBy];
+        if (property && property.type === "relation" && "relation" in property && property.relation?.direction === "owning") {
+          orderByField = table[`${orderBy}_id`];
+        }
+      }
+      return orderByField;
+    }
     /**
      * Build the `with` config for Drizzle's relational query API.
      * Converts collection relations to a Drizzle-compatible `with` object.
@@ -5164,12 +5612,10 @@
      */
     buildWithConfig(collection, include) {
       const resolvedRelations = resolveCollectionRelations(collection);
-      const propertyKeys = new Set(Object.keys(collection.properties || {}));
       const withConfig = {};
       const shouldInclude = (key) => !include || include.length === 0 || include[0] === "*" || include.includes(key);
       for (const [key, relation] of Object.entries(resolvedRelations)) {
         if (!shouldInclude(key)) continue;
-        if (!include && !propertyKeys.has(key)) continue;
         const drizzleRelName = relation.relationName || key;
         if (relation.joinPath && relation.joinPath.length > 0) {
           continue;
@@ -5219,10 +5665,8 @@
      */
     drizzleResultToEntity(row, collection, collectionPath, idInfo, databaseId, idInfoArray) {
       const resolvedRelations = resolveCollectionRelations(collection);
-      const propertyKeys = new Set(Object.keys(collection.properties || {}));
       const normalizedValues = normalizeDbValues(row, collection);
       for (const [key, relation] of Object.entries(resolvedRelations)) {
-        if (!propertyKeys.has(key)) continue;
         const drizzleRelName = relation.relationName || key;
         const relData = row[drizzleRelName];
         if (relData === void 0 || relData === null) continue;
@@ -5241,17 +5685,12 @@
             }
             const relId = String(targetEntity[targetIdField] ?? targetEntity.id ?? targetEntity[Object.keys(targetEntity)[0]]);
             const targetValues = normalizeDbValues(targetEntity, targetCollection);
-            return {
+            return createRelationRefWithData(relId, targetPath, {
               id: relId,
               path: targetPath,
-              __type: "relation",
-              data: {
-                id: relId,
-                path: targetPath,
-                values: targetValues,
-                databaseId
-              }
-            };
+              values: targetValues,
+              databaseId
+            });
           });
         } else if (relation.cardinality === "one" && typeof relData === "object" && !Array.isArray(relData)) {
           const targetCollection = relation.target();
@@ -5261,17 +5700,12 @@
           const relObj = relData;
           const relId = String(relObj[targetIdField] ?? relObj.id ?? relObj[Object.keys(relObj)[0]]);
           const targetValues = normalizeDbValues(relObj, targetCollection);
-          normalizedValues[key] = {
+          normalizedValues[key] = createRelationRefWithData(relId, targetPath, {
             id: relId,
             path: targetPath,
-            __type: "relation",
-            data: {
-              id: relId,
-              path: targetPath,
-              values: targetValues,
-              databaseId
-            }
-          };
+            values: targetValues,
+            databaseId
+          });
         }
       }
       return {
@@ -5288,27 +5722,16 @@
      */
     async resolveJoinPathRelations(entity, collection, collectionPath, parsedId, databaseId) {
       const resolvedRelations = resolveCollectionRelations(collection);
-      const propertyKeys = new Set(Object.keys(collection.properties || {}));
-      const promises = Object.entries(resolvedRelations).filter(([key, relation]) => propertyKeys.has(key) && relation.joinPath && relation.joinPath.length > 0).map(async ([key, relation]) => {
+      const promises = Object.entries(resolvedRelations).filter(([key, relation]) => relation.joinPath && relation.joinPath.length > 0).map(async ([key, relation]) => {
         try {
           const relatedEntities = await this.relationService.fetchRelatedEntities(collectionPath, parsedId, key, {
             limit: relation.cardinality === "one" ? 1 : void 0
           });
           if (relation.cardinality === "one" && relatedEntities.length > 0) {
             const e = relatedEntities[0];
-            entity.values[key] = {
-              id: e.id,
-              path: e.path,
-              __type: "relation",
-              data: e
-            };
+            entity.values[key] = createRelationRefWithData(e.id, e.path, e);
           } else if (relation.cardinality === "many") {
-            entity.values[key] = relatedEntities.map((e) => ({
-              id: e.id,
-              path: e.path,
-              __type: "relation",
-              data: e
-            }));
+            entity.values[key] = relatedEntities.map((e) => createRelationRefWithData(e.id, e.path, e));
           }
         } catch (e) {
           console.warn(`Could not resolve joinPath relation '${key}':`, e);
@@ -5323,8 +5746,7 @@
     async resolveJoinPathRelationsBatch(entities, collection, collectionPath, idInfo, databaseId) {
       if (entities.length === 0) return;
       const resolvedRelations = resolveCollectionRelations(collection);
-      const propertyKeys = new Set(Object.keys(collection.properties || {}));
-      const joinPathRelations = Object.entries(resolvedRelations).filter(([key, relation]) => propertyKeys.has(key) && relation.joinPath && relation.joinPath.length > 0);
+      const joinPathRelations = Object.entries(resolvedRelations).filter(([key, relation]) => relation.joinPath && relation.joinPath.length > 0);
       if (joinPathRelations.length === 0) return;
       for (const [key, relation] of joinPathRelations) {
         try {
@@ -5336,15 +5758,10 @@
           for (const entity of entities) {
             const parsed = parseIdValues(entity.id, [idInfo]);
             const entityId = parsed[idInfo.fieldName];
-            const relatedEntity = resultMap.get(entityId);
+            const relatedEntity = resultMap.get(String(entityId));
             if (relatedEntity) {
               if (relation.cardinality === "one") {
-                entity.values[key] = {
-                  id: relatedEntity.id,
-                  path: relatedEntity.path,
-                  __type: "relation",
-                  data: relatedEntity
-                };
+                entity.values[key] = createRelationRefWithData(relatedEntity.id, relatedEntity.path, relatedEntity);
               }
             }
           }
@@ -5354,22 +5771,72 @@
       }
     }
     /**
-     * Convert a db.query result row to a flat REST-style object with populated relations.
+     * Resolves joinPath relations for raw REST rows and directly injects them.
+     * Uses RelationService to query the database and maps results back to the flattened objects.
      */
-    drizzleResultToRestRow(row, collection, idInfo, idInfoArray) {
-      const flat = {
-        id: idInfoArray && idInfoArray.length > 1 ? buildCompositeId(row, idInfoArray) : String(row[idInfo.fieldName])
-      };
+    async resolveJoinPathRelationsBatchRest(rows, collection, collectionPath, idInfoArray, include) {
+      if (rows.length === 0) return;
       const resolvedRelations = resolveCollectionRelations(collection);
-      for (const [k, v] of Object.entries(row)) {
-        if (k === idInfo.fieldName) continue;
-        const relation = resolvedRelations[k];
-        if (Array.isArray(v) && relation) {
-          flat[k] = v.map((item) => {
-            if (this.isJunctionRelation(relation, collection)) {
-              const nestedKey = Object.keys(item).find((nk) => typeof item[nk] === "object" && item[nk] !== null && !Array.isArray(item[nk]));
-              if (nestedKey) {
-                const nested = item[nestedKey];
+      const propertyKeys = new Set(Object.keys(collection.properties || {}));
+      const shouldInclude = (key) => !include || include.length === 0 || include[0] === "*" || include.includes(key);
+      const joinPathRelations = Object.entries(resolvedRelations).filter(([key, relation]) => relation.joinPath && relation.joinPath.length > 0 && propertyKeys.has(key) && shouldInclude(key));
+      if (joinPathRelations.length === 0) return;
+      const idInfo = idInfoArray[0];
+      for (const [key, relation] of joinPathRelations) {
+        try {
+          const entityIds = rows.map((r) => {
+            const parsed = parseIdValues(String(r.id), idInfoArray);
+            return parsed[idInfo.fieldName];
+          });
+          if (relation.cardinality === "one") {
+            const resultMap = await this.relationService.batchFetchRelatedEntities(collectionPath, entityIds, key, relation);
+            for (const row of rows) {
+              const parsed = parseIdValues(String(row.id), idInfoArray);
+              const entityId = parsed[idInfo.fieldName];
+              const relatedEntity = resultMap.get(String(entityId));
+              if (relatedEntity) {
+                row[key] = {
+                  id: relatedEntity.id,
+                  ...relatedEntity.values
+                };
+              } else {
+                row[key] = null;
+              }
+            }
+          } else if (relation.cardinality === "many") {
+            const resultMap = await this.batchFetchManyRelatedEntities(collectionPath, entityIds, key);
+            for (const row of rows) {
+              const parsed = parseIdValues(String(row.id), idInfoArray);
+              const entityId = parsed[idInfo.fieldName];
+              const relatedList = resultMap.get(String(entityId)) || [];
+              row[key] = relatedList.map((e) => ({
+                id: e.id,
+                ...e.values
+              }));
+            }
+          }
+        } catch (e) {
+          console.warn(`Could not batch resolve joinPath relation '${key}' for REST:`, e);
+        }
+      }
+    }
+    /**
+     * Convert a db.query result row to a flat REST-style object with populated relations.
+     */
+    drizzleResultToRestRow(row, collection, idInfo, idInfoArray) {
+      const flat = {
+        id: idInfoArray && idInfoArray.length > 1 ? buildCompositeId(row, idInfoArray) : String(row[idInfo.fieldName])
+      };
+      const resolvedRelations = resolveCollectionRelations(collection);
+      for (const [k, v] of Object.entries(row)) {
+        if (k === idInfo.fieldName) continue;
+        const relation = findRelation(resolvedRelations, k);
+        if (Array.isArray(v) && relation) {
+          flat[k] = v.map((item) => {
+            if (this.isJunctionRelation(relation, collection)) {
+              const nestedKey = Object.keys(item).find((nk) => typeof item[nk] === "object" && item[nk] !== null && !Array.isArray(item[nk]));
+              if (nestedKey) {
+                const nested = item[nestedKey];
                 return {
                   id: String(nested.id ?? nested[Object.keys(nested)[0]]),
                   ...nested
@@ -5415,7 +5882,7 @@
         if (filterConditions.length > 0) allConditions.push(...filterConditions);
       }
       if (options.startAfter) {
-        const cursorConditions = this.buildCursorConditions(table, idField, idInfo, options);
+        const cursorConditions = this.buildCursorConditions(table, idField, idInfo, options, collectionPath);
         if (cursorConditions.length > 0) allConditions.push(...cursorConditions);
       }
       if (allConditions.length > 0) {
@@ -5423,7 +5890,8 @@
       }
       const orderExpressions = [];
       if (options.orderBy) {
-        const orderByField = table[options.orderBy];
+        const collection = getCollectionByPath(collectionPath, this.registry);
+        const orderByField = this.resolveOrderByField(table, options.orderBy, collection);
         if (orderByField) {
           orderExpressions.push(options.order === "asc" ? drizzleOrm.asc(orderByField) : drizzleOrm.desc(orderByField));
         }
@@ -5434,16 +5902,18 @@
       }
       const limitValue = options.searchString ? options.limit || 50 : options.limit;
       if (limitValue) queryOpts.limit = limitValue;
+      if (options.offset && options.offset > 0) queryOpts.offset = options.offset;
       return queryOpts;
     }
     /**
      * Extract cursor pagination conditions from startAfter options.
      */
-    buildCursorConditions(table, idField, idInfo, options) {
+    buildCursorConditions(table, idField, idInfo, options, collectionPath) {
       if (!options.startAfter) return [];
       const cursor = options.startAfter;
       if (options.orderBy) {
-        const orderByField = table[options.orderBy];
+        const collection = collectionPath ? getCollectionByPath(collectionPath, this.registry) : void 0;
+        const orderByField = this.resolveOrderByField(table, options.orderBy, collection);
         if (orderByField) {
           const startAfterOrderValue = cursor.values?.[options.orderBy] ?? cursor[options.orderBy];
           const startAfterId = cursor.id ?? cursor[idInfo.fieldName];
@@ -5505,11 +5975,7 @@
       const relationPromises = Object.entries(resolvedRelations).filter(([key]) => propertyKeys.has(key)).map(async ([key, relation]) => {
         if (relation.cardinality === "many") {
           const relatedEntities = await this.relationService.fetchRelatedEntities(collectionPath, parsedId, key, {});
-          values[key] = relatedEntities.map((e) => ({
-            id: e.id,
-            path: e.path,
-            __type: "relation"
-          }));
+          values[key] = relatedEntities.map((e) => createRelationRef(e.id, e.path));
         } else if (relation.cardinality === "one") {
           if (values[key] == null) {
             try {
@@ -5518,11 +5984,7 @@
               });
               if (relatedEntities.length > 0) {
                 const e = relatedEntities[0];
-                values[key] = {
-                  id: e.id,
-                  path: e.path,
-                  __type: "relation"
-                };
+                values[key] = createRelationRef(e.id, e.path);
               }
             } catch (e) {
               console.warn(`Could not resolve one-to-one relation property: ${key}`, e);
@@ -5552,13 +6014,13 @@
       }
       const tableName = drizzleOrm.getTableName(table);
       const qb = this.getQueryBuilder(tableName);
-      if (qb) {
+      const withConfig = this.buildWithConfig(collection);
+      const hasRelations = withConfig && Object.keys(withConfig).length > 0;
+      if (qb && !options.searchString && !hasRelations) {
         try {
-          const withConfig = this.buildWithConfig(collection);
-          const queryOpts = this.buildDrizzleQueryOptions(table, idField, idInfo, options, collectionPath, withConfig);
+          const queryOpts = this.buildDrizzleQueryOptions(table, idField, idInfo, options, collectionPath, void 0);
           const results2 = await qb.findMany(queryOpts);
           const entities = results2.map((row) => this.drizzleResultToEntity(row, collection, collectionPath, idInfo, options.databaseId, idInfoArray));
-          await this.resolveJoinPathRelationsBatch(entities, collection, collectionPath, idInfo, options.databaseId);
           return entities;
         } catch (e) {
           console.warn(`[EntityFetchService] db.query.findMany failed for ${collectionPath}, falling back to db.select:`, e);
@@ -5581,7 +6043,7 @@
       }
       const orderExpressions = [];
       if (options.orderBy) {
-        const orderByField = table[options.orderBy];
+        const orderByField = this.resolveOrderByField(table, options.orderBy, collection);
         if (orderByField) {
           orderExpressions.push(options.order === "asc" ? drizzleOrm.asc(orderByField) : drizzleOrm.desc(orderByField));
         }
@@ -5589,7 +6051,7 @@
       orderExpressions.push(drizzleOrm.desc(idField));
       if (orderExpressions.length > 0) query = query.orderBy(...orderExpressions);
       if (options.startAfter) {
-        const cursorConditions = this.buildCursorConditions(table, idField, idInfo, options);
+        const cursorConditions = this.buildCursorConditions(table, idField, idInfo, options, collectionPath);
         if (cursorConditions.length > 0) {
           allConditions.push(...cursorConditions);
           const finalCondition = DrizzleConditionBuilder.combineConditionsWithAnd(allConditions);
@@ -5598,6 +6060,7 @@
       }
       const limitValue = options.searchString ? options.limit || 50 : options.limit;
       if (limitValue) query = query.limit(limitValue);
+      if (options.offset && options.offset > 0) query = query.offset(options.offset);
       const results = await query;
       return this.processEntityResults(results, collection, collectionPath, idInfo, options.databaseId, false, idInfoArray);
     }
@@ -5611,7 +6074,7 @@
     async processEntityResults(results, collection, collectionPath, idInfo, databaseId, skipRelations = false, idInfoArray) {
       if (results.length === 0) return [];
       const entitiesWithValues = await Promise.all(results.map(async (entity) => {
-        const values = await parseDataFromServer(entity, collection, this.db, this.registry);
+        const values = await parseDataFromServer(entity, collection);
         return {
           entity,
           values,
@@ -5636,37 +6099,29 @@
             const relationResults = await this.relationService.batchFetchRelatedEntities(collectionPath, entityIds, key, relation);
             entitiesMissingRelation.forEach((item) => {
               const entityId = item.entity[idInfo.fieldName];
-              const relatedEntity = relationResults.get(entityId);
+              const relatedEntity = relationResults.get(String(entityId));
               if (relatedEntity) {
-                item.values[key] = {
-                  id: relatedEntity.id,
-                  path: relatedEntity.path,
-                  __type: "relation",
-                  data: relatedEntity
-                };
+                item.values[key] = createRelationRefWithData(relatedEntity.id, relatedEntity.path, relatedEntity);
               }
             });
           } catch (e) {
             console.warn(`Could not batch load one-to-one relation property: ${key}`, e);
           }
         }
-        const manyRelationPromises = entitiesWithValues.map(async (item) => {
-          const manyRelationQueries = Object.entries(resolvedRelations).filter(([key, relation]) => propertyKeys.has(key) && relation.cardinality === "many").map(async ([key]) => {
-            try {
-              const relatedEntities = await this.relationService.fetchRelatedEntities(collectionPath, item.entity[idInfo.fieldName], key, {});
-              item.values[key] = relatedEntities.map((e) => ({
-                id: e.id,
-                path: e.path,
-                __type: "relation",
-                data: e
-              }));
-            } catch (e) {
-              console.warn(`Could not resolve many relation property: ${key}`, e);
-            }
-          });
-          await Promise.all(manyRelationQueries);
-        });
-        await Promise.all(manyRelationPromises);
+        const manyRelations = Object.entries(resolvedRelations).filter(([key, relation]) => propertyKeys.has(key) && relation.cardinality === "many");
+        for (const [key, relation] of manyRelations) {
+          try {
+            const entityIds = entitiesWithValues.map((item) => item.entity[idInfo.fieldName]);
+            const relationResults = await this.relationService.batchFetchRelatedEntitiesMany(collectionPath, entityIds, key, relation);
+            entitiesWithValues.forEach((item) => {
+              const entityId = String(item.entity[idInfo.fieldName]);
+              const relatedEntities = relationResults.get(entityId) || [];
+              item.values[key] = relatedEntities.map((e) => createRelationRefWithData(e.id, e.path, e));
+            });
+          } catch (e) {
+            console.warn(`Could not batch load many relation property: ${key}`, e);
+          }
+        }
       }
       return entitiesWithValues.map((item) => ({
         id: item.id,
@@ -5707,12 +6162,16 @@
       for (let i = 2; i < pathSegments.length; i += 2) {
         const relationKey = pathSegments[i];
         const resolvedRelations = resolveCollectionRelations(currentCollection);
-        const relation = resolvedRelations[relationKey];
+        const relation = findRelation(resolvedRelations, relationKey);
         if (!relation) {
           throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'`);
         }
         if (i === pathSegments.length - 1) {
-          return this.relationService.fetchRelatedEntities(currentCollection.slug, currentEntityId, relationKey, options);
+          const entities = await this.relationService.fetchRelatedEntities(currentCollection.slug, currentEntityId, relationKey, options);
+          for (const entity of entities) {
+            entity.path = path2;
+          }
+          return entities;
         }
         if (i + 1 < pathSegments.length) {
           const nextEntityId = pathSegments[i + 1];
@@ -5734,11 +6193,19 @@
       let query = this.db.select({
         count: drizzleOrm.count()
       }).from(table).$dynamic();
+      const allConditions = [];
+      if (options.searchString) {
+        const searchConditions = DrizzleConditionBuilder.buildSearchConditions(options.searchString, collection.properties, table);
+        if (searchConditions.length === 0) return 0;
+        allConditions.push(DrizzleConditionBuilder.combineConditionsWithOr(searchConditions));
+      }
       if (options.filter) {
         const filterConditions = this.buildFilterConditions(options.filter, table, collectionPath);
-        if (filterConditions.length > 0) {
-          query = query.where(drizzleOrm.and(...filterConditions));
-        }
+        if (filterConditions.length > 0) allConditions.push(...filterConditions);
+      }
+      if (allConditions.length > 0) {
+        const finalCondition = DrizzleConditionBuilder.combineConditionsWithAnd(allConditions);
+        if (finalCondition) query = query.where(finalCondition);
       }
       const result = await query;
       return Number(result[0]?.count || 0);
@@ -5757,7 +6224,7 @@
       for (let i = 2; i < pathSegments.length; i += 2) {
         const relationKey = pathSegments[i];
         const resolvedRelations = resolveCollectionRelations(currentCollection);
-        const relation = resolvedRelations[relationKey];
+        const relation = findRelation(resolvedRelations, relationKey);
         if (!relation) {
           throw new Error(`Relation '${relationKey}' not found`);
         }
@@ -5816,12 +6283,14 @@
       const idField = table[idInfo.fieldName];
       const tableName = drizzleOrm.getTableName(table);
       const qb = this.getQueryBuilder(tableName);
-      if (qb) {
+      if (qb && !options.searchString) {
         try {
           const withConfig = include && include.length > 0 ? this.buildWithConfig(collection, include) : void 0;
           const queryOpts = this.buildDrizzleQueryOptions(table, idField, idInfo, options, collectionPath, withConfig);
           const results = await qb.findMany(queryOpts);
-          return results.map((row) => this.drizzleResultToRestRow(row, collection, idInfo, idInfoArray));
+          const restRows = results.map((row) => this.drizzleResultToRestRow(row, collection, idInfo, idInfoArray));
+          await this.resolveJoinPathRelationsBatchRest(restRows, collection, collectionPath, idInfoArray, include);
+          return restRows;
         } catch (e) {
           console.warn(`[fetchCollectionForRest] db.query.findMany failed for ${collectionPath}, falling back:`, e);
         }
@@ -5843,7 +6312,7 @@
           const batchResults = await this.relationService.batchFetchRelatedEntities(collectionPath, entityIds, key, relation);
           for (const entity of entities) {
             const eid = entity[idInfo.fieldName];
-            const related = batchResults.get(eid);
+            const related = batchResults.get(String(eid));
             if (related) {
               entity[key] = {
                 id: related.id,
@@ -5899,7 +6368,9 @@
             } : {}
           });
           if (!row) return null;
-          return this.drizzleResultToRestRow(row, collection, idInfo, idInfoArray);
+          const restRow = this.drizzleResultToRestRow(row, collection, idInfo, idInfoArray);
+          await this.resolveJoinPathRelationsBatchRest([restRow], collection, collectionPath, idInfoArray, include);
+          return restRow;
         } catch (e) {
           console.warn(`[fetchEntityForRest] db.query.findFirst failed for ${collectionPath}, falling back:`, e);
         }
@@ -5967,7 +6438,7 @@
       }
       const orderExpressions = [];
       if (options.orderBy) {
-        const orderByField = table[options.orderBy];
+        const orderByField = this.resolveOrderByField(table, options.orderBy, collection);
         if (orderByField) {
           orderExpressions.push(options.order === "asc" ? drizzleOrm.asc(orderByField) : drizzleOrm.desc(orderByField));
         }
@@ -5976,6 +6447,7 @@
       if (orderExpressions.length > 0) query = query.orderBy(...orderExpressions);
       const limitValue = options.searchString ? options.limit || 50 : options.limit;
       if (limitValue) query = query.limit(limitValue);
+      if (options.offset && options.offset > 0) query = query.offset(options.offset);
       return await query;
     }
     /**
@@ -6024,7 +6496,7 @@
           }
         }
         if (options.orderBy) {
-          const orderByField = table[options.orderBy];
+          const orderByField = this.resolveOrderByField(table, options.orderBy, collection);
           if (orderByField) {
             queryOpts.orderBy = options.order === "asc" ? drizzleOrm.asc(orderByField) : drizzleOrm.desc(orderByField);
           }
@@ -6078,17 +6550,15 @@
      * Groups results by parent ID to avoid N+1.
      */
     async batchFetchManyRelatedEntities(parentCollectionPath, parentIds, relationKey) {
-      const resultMap = /* @__PURE__ */ new Map();
-      const batchPromises = parentIds.map(async (parentId) => {
-        try {
-          const related = await this.relationService.fetchRelatedEntities(parentCollectionPath, parentId, relationKey, {});
-          resultMap.set(String(parentId), related);
-        } catch (e) {
-          resultMap.set(String(parentId), []);
-        }
-      });
-      await Promise.all(batchPromises);
-      return resultMap;
+      if (parentIds.length === 0) return /* @__PURE__ */ new Map();
+      const collection = getCollectionByPath(parentCollectionPath, this.registry);
+      const resolvedRelations = resolveCollectionRelations(collection);
+      const relation = resolvedRelations[relationKey];
+      if (!relation) {
+        console.warn(`[batchFetchManyRelatedEntities] Relation '${relationKey}' not found, skipping`);
+        return /* @__PURE__ */ new Map();
+      }
+      return this.relationService.batchFetchRelatedEntitiesMany(parentCollectionPath, parentIds, relationKey, relation);
     }
   }
   class EntityPersistService {
@@ -6124,6 +6594,7 @@
       const effectiveValues = {
         ...values
       };
+      let junctionTableInfo;
       if (collectionPath.includes("/")) {
         const segments = collectionPath.split("/").filter(Boolean);
         if (segments.length >= 3 && segments.length % 2 === 1) {
@@ -6133,9 +6604,10 @@
           for (let i = 2; i < segments.length; i += 2) {
             const relationKey = segments[i];
             const resolvedRelations2 = resolveCollectionRelations(currentCollection);
-            const relation = resolvedRelations2[relationKey];
+            const relation = findRelation(resolvedRelations2, relationKey);
             if (!relation) {
-              throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'`);
+              const available = Object.keys(resolvedRelations2).join(", ") || "(none)";
+              throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'. Available relations: [${available}]`);
             }
             if (i === segments.length - 1) {
               const targetCollection = relation.target();
@@ -6145,7 +6617,7 @@
                 const parentIdInfo2 = parentIdInfoArray2[0];
                 const parsedParentIdObj2 = parseIdValues(currentEntityId, parentIdInfoArray2);
                 const parsedParentId2 = parsedParentIdObj2[parentIdInfo2.fieldName];
-                effectiveValues.__junction_table_info = {
+                junctionTableInfo = {
                   parentCollection: currentCollection,
                   parentId: parsedParentId2,
                   relation,
@@ -6214,14 +6686,10 @@
           }
         }
       }
-      const processedData = serializeDataToServer(otherValues, collection.properties, collection, this.registry);
-      const inverseRelationUpdates = processedData.__inverseRelationUpdates || [];
-      const joinPathRelationUpdates = processedData.__joinPathRelationUpdates || [];
-      const junctionTableInfo = processedData.__junction_table_info;
-      delete processedData.__inverseRelationUpdates;
-      delete processedData.__joinPathRelationUpdates;
-      delete processedData.__junction_table_info;
-      const entityData = sanitizeAndConvertDates(processedData);
+      const serializedResult = serializeDataToServer(otherValues, collection.properties, collection, this.registry);
+      const inverseRelationUpdates = serializedResult.inverseRelationUpdates;
+      const joinPathRelationUpdates = serializedResult.joinPathRelationUpdates;
+      const entityData = sanitizeAndConvertDates(serializedResult.scalarData);
       let savedId;
       try {
         savedId = await this.db.transaction(async (tx) => {
@@ -6234,7 +6702,7 @@
             }
             const scalarKeys = Object.keys(entityData);
             if (scalarKeys.length > 0) {
-              let updateQuery = tx.update(table).set(entityData);
+              const updateQuery = tx.update(table).set(entityData);
               const conditions = [];
               for (const info of idInfoArray) {
                 const field = table[info.fieldName];
@@ -6598,21 +7066,6 @@
       if (poolManager) {
         this.branchService = new BranchService(db, poolManager);
       }
-      this.admin = {
-        executeSql: this.executeSql.bind(this),
-        fetchAvailableDatabases: this.fetchAvailableDatabases.bind(this),
-        fetchAvailableRoles: this.fetchAvailableRoles.bind(this),
-        fetchCurrentDatabase: this.fetchCurrentDatabase.bind(this),
-        fetchUnmappedTables: this.fetchUnmappedTables.bind(this),
-        fetchTableMetadata: this.fetchTableMetadata.bind(this),
-        // Branch operations (only available when poolManager is configured)
-        ...this.branchService ? {
-          createBranch: this.branchService.createBranch.bind(this.branchService),
-          deleteBranch: this.branchService.deleteBranch.bind(this.branchService),
-          listBranches: this.branchService.listBranches.bind(this.branchService),
-          getBranchInfo: this.branchService.getBranchInfo.bind(this.branchService)
-        } : {}
-      };
     }
     key = "postgres";
     initialised = true;
@@ -6630,8 +7083,26 @@
     _pendingNotifications = [];
     /**
      * Typed admin capabilities (SQLAdmin + SchemaAdmin + BranchAdmin).
+     * Implemented as a getter so method references are resolved at call-time,
+     * allowing test spies applied after construction to take effect.
      */
-    admin;
+    get admin() {
+      return {
+        executeSql: (...args) => this.executeSql(...args),
+        fetchAvailableDatabases: () => this.fetchAvailableDatabases(),
+        fetchAvailableRoles: () => this.fetchAvailableRoles(),
+        fetchCurrentDatabase: () => this.fetchCurrentDatabase(),
+        fetchUnmappedTables: (...args) => this.fetchUnmappedTables(...args),
+        fetchTableMetadata: (...args) => this.fetchTableMetadata(...args),
+        // Branch operations (only available when poolManager is configured)
+        ...this.branchService ? {
+          createBranch: this.branchService.createBranch.bind(this.branchService),
+          deleteBranch: this.branchService.deleteBranch.bind(this.branchService),
+          listBranches: this.branchService.listBranches.bind(this.branchService),
+          getBranchInfo: this.branchService.getBranchInfo.bind(this.branchService)
+        } : {}
+      };
+    }
     resolveCollectionCallbacks(collection, path2) {
       if (!collection && !path2) return {
         collection: void 0,
@@ -6660,6 +7131,7 @@
       collection,
       filter,
       limit,
+      offset,
       startAfter,
       orderBy,
       searchString,
@@ -6670,6 +7142,7 @@
         orderBy,
         order,
         limit,
+        offset,
         startAfter,
         databaseId: collection?.databaseId,
         searchString
@@ -6713,6 +7186,7 @@
       collection,
       filter,
       limit,
+      offset,
       startAfter,
       orderBy,
       searchString,
@@ -6733,6 +7207,7 @@
           orderBy,
           order,
           limit,
+          offset,
           startAfter,
           databaseId: collection?.databaseId,
           searchString
@@ -6744,6 +7219,7 @@
         collection,
         filter,
         limit,
+        offset,
         startAfter,
         orderBy,
         searchString,
@@ -6904,7 +7380,7 @@
               collection: resolvedCollection,
               path: path2,
               entityId: savedEntity.id,
-              values: updatedValues,
+              values: savedEntity.values,
               previousValues: previousValuesForHistory,
               status,
               context: contextForCallback
@@ -6915,7 +7391,7 @@
               collection: resolvedCollection,
               path: path2,
               entityId: savedEntity.id,
-              values: updatedValues,
+              values: savedEntity.values,
               previousValues: previousValuesForHistory,
               status,
               context: contextForCallback
@@ -7052,10 +7528,12 @@
     async countEntities({
       path: path2,
       collection,
-      filter
+      filter,
+      searchString
     }) {
       return this.entityService.countEntities(path2, {
-        filter
+        filter,
+        searchString
       });
     }
     getTargetDb(databaseName) {
@@ -7111,7 +7589,7 @@
       return databases;
     }
     async fetchAvailableRoles() {
-      const result = await this.executeSql(`SELECT rolname FROM pg_roles;`);
+      const result = await this.executeSql("SELECT rolname FROM pg_roles;");
       return result.map((r) => r.rolname);
     }
     async fetchCurrentDatabase() {
@@ -7285,12 +7763,12 @@
       const result = await this.delegate.db.transaction(async (tx) => {
         let userId = this.user?.uid;
         if (!userId) {
-          console.warn(`[DataDriver] User ID (uid) is missing for authenticated delegate. Using 'anonymous'. User object:`, this.user);
+          console.warn("[DataDriver] User ID (uid) is missing for authenticated delegate. Using 'anonymous'. User object:", this.user);
           userId = "anonymous";
         }
-        let userRoles2 = this.user?.roles ?? [];
+        const userRoles2 = this.user?.roles ?? [];
         if (!this.user?.roles) {
-          console.warn(`[DataDriver] User roles are missing for authenticated delegate. Using empty array. User object:`, this.user);
+          console.warn("[DataDriver] User roles are missing for authenticated delegate. Using empty array. User object:", this.user);
         }
         const normalizedRoles = userRoles2.map((r) => typeof r === "string" ? r : r?.id ?? String(r));
         const rolesString = normalizedRoles.join(",");
@@ -7360,29 +7838,6 @@
     async countEntities(props) {
       return this.withTransaction((delegate) => delegate.countEntities(props));
     }
-    /**
-     * Intentionally delegates to the base delegate WITHOUT RLS wrapping.
-     * executeSql is an admin-only feature; access control should be enforced
-     * at the API route level, not via database-level RLS.
-     */
-    async executeSql(sqlText, options) {
-      return this.delegate.executeSql(sqlText, options);
-    }
-    async fetchAvailableDatabases() {
-      return this.delegate.fetchAvailableDatabases();
-    }
-    async fetchAvailableRoles() {
-      return this.delegate.fetchAvailableRoles();
-    }
-    async fetchCurrentDatabase() {
-      return this.delegate.fetchCurrentDatabase();
-    }
-    async fetchUnmappedTables(mappedPaths) {
-      return this.delegate.fetchUnmappedTables(mappedPaths);
-    }
-    async fetchTableMetadata(tableName) {
-      return this.delegate.fetchTableMetadata(tableName);
-    }
   }
   class DatabasePoolManager {
     pools = /* @__PURE__ */ new Map();
@@ -7418,7 +7873,10 @@
         connectionString: url2.toString(),
         max: 10,
         // Default sensible limit, can be tuned later
-        idleTimeoutMillis: 3e4
+        idleTimeoutMillis: 1e4,
+        // Reduced from 30000 for aggressive cleanup
+        allowExitOnIdle: true
+        // Prevent idle clients from hanging the Node.js process
       });
       pool.on("error", (err) => {
         console.error(`[DatabasePoolManager] Unexpected error on idle client for db ${databaseName}`, err);
@@ -7469,13 +7927,6 @@
     photoUrl: pgCore.varchar("photo_url", {
       length: 500
     }),
-    provider: pgCore.varchar("provider", {
-      length: 50
-    }).notNull().default("email"),
-    // 'email' | 'google'
-    googleId: pgCore.varchar("google_id", {
-      length: 255
-    }).unique(),
     emailVerified: pgCore.boolean("email_verified").default(false).notNull(),
     emailVerificationToken: pgCore.varchar("email_verification_token", {
       length: 255
@@ -7549,12 +8000,31 @@
     value: pgCore.jsonb("value").notNull(),
     updatedAt: pgCore.timestamp("updated_at").defaultNow().notNull()
   });
+  const userIdentities = rebaseSchema.table("user_identities", {
+    id: pgCore.uuid("id").defaultRandom().primaryKey(),
+    userId: pgCore.uuid("user_id").notNull().references(() => users.id, {
+      onDelete: "cascade"
+    }),
+    provider: pgCore.varchar("provider", {
+      length: 50
+    }).notNull(),
+    // e.g. 'google', 'linkedin'
+    providerId: pgCore.varchar("provider_id", {
+      length: 255
+    }).notNull(),
+    profileData: pgCore.jsonb("profile_data"),
+    createdAt: pgCore.timestamp("created_at").defaultNow().notNull(),
+    updatedAt: pgCore.timestamp("updated_at").defaultNow().notNull()
+  }, (table) => ({
+    uniqueProviderId: pgCore.unique("unique_provider_id").on(table.provider, table.providerId)
+  }));
   const usersRelations = drizzleOrm.relations(users, ({
     many
   }) => ({
     userRoles: many(userRoles),
     refreshTokens: many(refreshTokens),
-    passwordResetTokens: many(passwordResetTokens)
+    passwordResetTokens: many(passwordResetTokens),
+    userIdentities: many(userIdentities)
   }));
   const rolesRelations = drizzleOrm.relations(roles, ({
     many
@@ -7589,13 +8059,24 @@
       references: [users.id]
     })
   }));
+  const userIdentitiesRelations = drizzleOrm.relations(userIdentities, ({
+    one
+  }) => ({
+    user: one(users, {
+      fields: [userIdentities.userId],
+      references: [users.id]
+    })
+  }));
   const getPrimaryKeyProp = (collection) => {
     if (collection.properties) {
       const idPropEntry = Object.entries(collection.properties).find(([_, prop]) => "isId" in prop && Boolean(prop.isId));
       if (idPropEntry) {
+        const prop = idPropEntry[1];
+        const isUuid2 = prop.type === "string" && "isId" in prop && prop.isId === "uuid";
         return {
           name: idPropEntry[0],
-          type: idPropEntry[1].type === "number" ? "number" : "string"
+          type: prop.type === "number" ? "number" : "string",
+          isUuid: isUuid2
         };
       }
     }
@@ -7603,12 +8084,15 @@
     if (idProp?.type === "number") {
       return {
         name: "id",
-        type: "number"
+        type: "number",
+        isUuid: false
       };
     }
+    const isUuid = idProp?.type === "string" && "isId" in idProp && idProp.isId === "uuid";
     return {
       name: "id",
-      type: "string"
+      type: "string",
+      isUuid: isUuid ?? false
     };
   };
   const isNumericId = (collection) => {
@@ -7622,7 +8106,7 @@
     const hasExplicitId = Object.values(collection.properties ?? {}).some((p) => "isId" in p && Boolean(p.isId));
     return !hasExplicitId && propName === "id";
   };
-  const getDrizzleColumn = (propName, prop, collection) => {
+  const getDrizzleColumn = (propName, prop, collection, collections) => {
     const colName = toSnakeCase(propName);
     let columnDefinition;
     switch (prop.type) {
@@ -7641,20 +8125,20 @@
           columnDefinition = `varchar("${colName}")`;
         }
         if (isIdProperty(propName, prop, collection)) {
-          columnDefinition += `.primaryKey()`;
+          columnDefinition += ".primaryKey()";
         }
         if ("isId" in stringProp && stringProp.isId !== "manual" && stringProp.isId !== true) {
           if (stringProp.isId === "uuid") {
-            columnDefinition += `.defaultRandom()`;
+            columnDefinition += ".defaultRandom()";
           } else if (stringProp.isId === "cuid") {
-            columnDefinition += `.default(sql\`cuid()\`)`;
+            columnDefinition += ".default(sql`cuid()`)";
           } else if (typeof stringProp.isId === "string") {
             const sqlContent = stringProp.isId.startsWith("sql`") && stringProp.isId.endsWith("`") ? stringProp.isId.substring(4, stringProp.isId.length - 1) : stringProp.isId;
             columnDefinition += `.default(sql\`${sqlContent}\`)`;
           }
         }
         if (stringProp.validation?.unique) {
-          columnDefinition += `.unique()`;
+          columnDefinition += ".unique()";
         }
         break;
       }
@@ -7676,10 +8160,10 @@
           columnDefinition = baseType;
         }
         if (isId) {
-          columnDefinition += `.primaryKey()`;
+          columnDefinition += ".primaryKey()";
         }
         if (numProp.validation?.unique) {
-          columnDefinition += `.unique()`;
+          columnDefinition += ".unique()";
         }
         break;
       }
@@ -7710,7 +8194,7 @@
       case "relation": {
         const refProp = prop;
         const resolvedRelations = resolveCollectionRelations(collection);
-        const relation = resolvedRelations[refProp.relationName ?? propName];
+        const relation = findRelation(resolvedRelations, refProp.relationName ?? propName);
         if (!relation || relation.direction !== "owning" || relation.cardinality !== "one") {
           return null;
         }
@@ -7729,8 +8213,9 @@
         }
         const fkColumnName = toSnakeCase(relation.localKey);
         const targetTableVar = getTableVarName(getTableName(targetCollection));
-        const targetIdField = getPrimaryKeyName(targetCollection);
-        const baseColumn = isNumericId(targetCollection) ? `integer("${fkColumnName}")` : `varchar("${fkColumnName}")`;
+        const pkProp = getPrimaryKeyProp(targetCollection);
+        const targetIdField = pkProp.name;
+        const baseColumn = pkProp.type === "number" ? `integer("${fkColumnName}")` : pkProp.isUuid ? `uuid("${fkColumnName}")` : `varchar("${fkColumnName}")`;
         const onUpdate = relation.onUpdate ? `onUpdate: "${relation.onUpdate}"` : "";
         const required = prop.validation?.required;
         const onDeleteVal = relation.onDelete ?? (required ? "cascade" : "set null");
@@ -7743,6 +8228,26 @@
         }
         return `    ${relation.localKey}: ${columnDef}`;
       }
+      case "reference": {
+        const refProp = prop;
+        const targetCollection = collections.find((c) => c.slug === refProp.path || getTableName(c) === refProp.path);
+        if (!targetCollection) {
+          columnDefinition = `varchar("${colName}")`;
+          break;
+        }
+        const pkProp = getPrimaryKeyProp(targetCollection);
+        const targetTableVar = getTableVarName(getTableName(targetCollection));
+        const targetIdField = pkProp.name;
+        const baseColumn = pkProp.type === "number" ? `integer("${colName}")` : pkProp.isUuid ? `uuid("${colName}")` : `varchar("${colName}")`;
+        const required = prop.validation?.required;
+        const onDelete = required ? "cascade" : "set null";
+        const refOptions = `{ onDelete: "${onDelete}" }`;
+        columnDefinition = `${baseColumn}.references(() => ${targetTableVar}.${targetIdField}, ${refOptions})`;
+        if (required) {
+          columnDefinition += ".notNull()";
+        }
+        return `    ${propName}: ${columnDefinition}`;
+      }
       default:
         return null;
     }
@@ -7769,7 +8274,7 @@
       return resolveRawSql(rule.using);
     }
     if (rule.access === "public") {
-      return `sql\`true\``;
+      return "sql`true`";
     }
     if (rule.ownerField) {
       return `sql\`\${table.${rule.ownerField}} = auth.uid()\``;
@@ -7782,16 +8287,31 @@
     }
     return buildUsingClause(rule);
   };
+  const getPolicyNameHash = (rule) => {
+    const data = JSON.stringify({
+      a: rule.access,
+      m: rule.mode,
+      op: rule.operation,
+      ops: rule.operations?.slice().sort(),
+      own: rule.ownerField,
+      rol: rule.roles?.slice().sort(),
+      pg: rule.pgRoles?.slice().sort(),
+      u: rule.using,
+      w: rule.withCheck
+    });
+    return crypto.createHash("sha1").update(data).digest("hex").substring(0, 7);
+  };
   const generatePolicyCode = (tableName, rule, index) => {
     const ops = rule.operations && rule.operations.length > 0 ? rule.operations : [rule.operation ?? "all"];
+    const ruleHash = getPolicyNameHash(rule);
     return ops.map((op, opIdx) => {
-      const policyName = rule.name ? ops.length > 1 ? `${rule.name}_${op}` : rule.name : `${tableName}_${op}_policy_${index}${ops.length > 1 ? `_${opIdx}` : ""}`;
+      const policyName = rule.name ? ops.length > 1 ? `${rule.name}_${op}` : rule.name : `${tableName}_${op}_${ruleHash}${ops.length > 1 ? `_${opIdx}` : ""}`;
       return generateSinglePolicyCode(tableName, rule, op, policyName);
     }).join("");
   };
   const generateSinglePolicyCode = (tableName, rule, operation, policyName) => {
     const mode = rule.mode ?? "permissive";
-    const roles2 = rule.roles;
+    const roles2 = rule.roles ? [...rule.roles].sort() : void 0;
     const needsUsing = operation !== "insert";
     const needsWithCheck = operation !== "select" && operation !== "delete";
     let usingClause = needsUsing ? buildUsingClause(rule) : null;
@@ -7811,22 +8331,57 @@
       }
     }
     if (!usingClause && needsUsing) {
-      usingClause = `sql\`false\``;
+      usingClause = "sql`false`";
     }
     if (!withCheckClause && needsWithCheck) {
-      withCheckClause = `sql\`false\``;
+      withCheckClause = "sql`false`";
     }
     const parts = [];
     parts.push(`as: "${mode}"`);
     parts.push(`for: "${operation}"`);
-    const toRoles = rule.pgRoles ?? ["public"];
+    const toRoles = rule.pgRoles ? [...rule.pgRoles].sort() : ["public"];
     parts.push(`to: [${toRoles.map((r) => `"${r}"`).join(", ")}]`);
     if (usingClause) parts.push(`using: ${usingClause}`);
     if (withCheckClause) parts.push(`withCheck: ${withCheckClause}`);
     return `    pgPolicy("${policyName}", { ${parts.join(", ")} }),
 `;
   };
-  const generateSchema = async (collections) => {
+  const computeSharedRelationName = (rel, sourceCollection, _collections) => {
+    const fallback = rel.relationName ?? toSnakeCase(rel.target().slug);
+    if (rel.direction === "owning" && rel.cardinality === "one" && rel.localKey) {
+      return `${getTableName(sourceCollection)}_${rel.localKey}`;
+    }
+    if (rel.direction === "inverse" && rel.cardinality === "many" && rel.foreignKeyOnTarget) {
+      try {
+        const targetCollection = rel.target();
+        return `${getTableName(targetCollection)}_${rel.foreignKeyOnTarget}`;
+      } catch {
+        return fallback;
+      }
+    }
+    if (rel.direction === "inverse" && rel.cardinality === "one") {
+      if (rel.foreignKeyOnTarget) {
+        try {
+          const targetCollection = rel.target();
+          return `${getTableName(targetCollection)}_${rel.foreignKeyOnTarget}`;
+        } catch {
+          return fallback;
+        }
+      }
+      try {
+        const targetCollection = rel.target();
+        const targetResolvedRelations = resolveCollectionRelations(targetCollection);
+        const correspondingRelation = Object.values(targetResolvedRelations).find((targetRel) => targetRel.direction === "owning" && targetRel.cardinality === "one" && targetRel.localKey && targetRel.target().slug === sourceCollection.slug);
+        if (correspondingRelation && correspondingRelation.localKey) {
+          return `${getTableName(targetCollection)}_${correspondingRelation.localKey}`;
+        }
+      } catch {
+      }
+      return fallback;
+    }
+    return fallback;
+  };
+  const generateSchema = async (collections, stripPolicies = false) => {
     let schemaContent = "// This file is auto-generated by the Rebase Drizzle generator. Do not edit manually.\n\n";
     const hasUuid = collections.some((c) => c.properties && Object.values(c.properties).some((p) => p.type === "string" && (p.autoValue === "uuid" || p.isId === "uuid")));
     collections.some((c) => c.properties && Object.values(c.properties).some((p) => (p.type === "map" || p.type === "array") && p.columnType === "json"));
@@ -7834,9 +8389,7 @@
     if (hasUuid) pgCoreImports.push("uuid");
     schemaContent += `import { ${pgCoreImports.join(", ")} } from 'drizzle-orm/pg-core';
 `;
-    schemaContent += `import { relations as drizzleRelations, sql } from 'drizzle-orm';
-
-`;
+    schemaContent += "import { relations as drizzleRelations, sql } from 'drizzle-orm';\n\n";
     const exportedTableVars = [];
     const exportedEnumVars = [];
     const exportedRelationVars = [];
@@ -7897,8 +8450,8 @@
         } = relation.through;
         const onDelete = relation.onDelete ?? "cascade";
         const refOptions = `{ onDelete: "${onDelete}" }`;
-        const sourceColType = isNumericId(sourceCollection) ? "integer" : "varchar";
-        const targetColType = isNumericId(targetCollection) ? "integer" : "varchar";
+        const sourceColType = isNumericId(sourceCollection) ? "integer" : getPrimaryKeyProp(sourceCollection).isUuid ? "uuid" : "varchar";
+        const targetColType = isNumericId(targetCollection) ? "integer" : getPrimaryKeyProp(targetCollection).isUuid ? "uuid" : "varchar";
         const sourceId = getPrimaryKeyName(sourceCollection);
         const targetId = getPrimaryKeyName(targetCollection);
         schemaContent += `export const ${tableVarName} = pgTable("${tableName}", {
@@ -7907,31 +8460,28 @@
 `;
         schemaContent += `    ${targetColumn}: ${targetColType}("${toSnakeCase(targetColumn)}").notNull().references(() => ${getTableVarName(getTableName(targetCollection))}.${targetId}, ${refOptions}),
 `;
-        schemaContent += `}, (table) => ({
-`;
+        schemaContent += "}, (table) => ({\n";
         schemaContent += `    pk: primaryKey({ columns: [table.${sourceColumn}, table.${targetColumn}] })
 `;
-        schemaContent += `}));
-
-`;
+        schemaContent += "}));\n\n";
       } else if (!isJunction) {
         schemaContent += `export const ${tableVarName} = pgTable("${tableName}", {
 `;
         const columns = /* @__PURE__ */ new Set();
         Object.entries(collection.properties ?? {}).forEach(([propName, prop]) => {
-          const columnString = getDrizzleColumn(propName, prop, collection);
+          const columnString = getDrizzleColumn(propName, prop, collection, collections);
           if (columnString) columns.add(columnString);
         });
         const hasIdColumn = Array.from(columns).some((col) => col.includes(".primaryKey()"));
         if (!hasIdColumn) {
-          columns.add(`    id: varchar("id").primaryKey()`);
+          columns.add('    id: varchar("id").primaryKey()');
         }
         schemaContent += `${Array.from(columns).join(",\n")}`;
-        const securityRules = collection.securityRules;
-        if (securityRules && securityRules.length > 0) {
+        const securityRules = isPostgresCollection(collection) ? collection.securityRules : void 0;
+        if (!stripPolicies && securityRules && securityRules.length > 0) {
           schemaContent += "\n}, (table) => ([\n";
           securityRules.forEach((rule, idx) => {
-            schemaContent += generatePolicyCode(tableName, rule, idx);
+            schemaContent += generatePolicyCode(tableName, rule);
           });
           schemaContent += "])).enableRLS();\n\n";
         } else {
@@ -7971,13 +8521,13 @@
             }
           } catch {
           }
-          tableRelations.push(`    ${relation.through.sourceColumn}: one(${sourceTableVar}, {
+          tableRelations.push(`    "${relation.through.sourceColumn}": one(${sourceTableVar}, {
         fields: [${tableVarName}.${relation.through.sourceColumn}],
         references: [${sourceTableVar}.${sourceId}],
         relationName: "${owningRelationName}"
     })`);
           const targetRelName = inverseRelationName ?? owningRelationName;
-          tableRelations.push(`    ${relation.through.targetColumn}: one(${targetTableVar}, {
+          tableRelations.push(`    "${relation.through.targetColumn}": one(${targetTableVar}, {
         fields: [${tableVarName}.${relation.through.targetColumn}],
         references: [${targetTableVar}.${targetId}],
         relationName: "${targetRelName}"
@@ -7985,22 +8535,25 @@
         }
       } else {
         const resolvedRelations = resolveCollectionRelations(collection);
+        const emittedRelationNames = /* @__PURE__ */ new Set();
         for (const [relationKey, rel] of Object.entries(resolvedRelations)) {
           try {
             const target = rel.target();
             const targetTableVar = getTableVarName(getTableName(target));
-            const relationName = rel.relationName ?? relationKey;
-            const drizzleRelationName = relationName;
+            const drizzleRelationName = computeSharedRelationName(rel, collection, collections);
+            const deduplicationKey = `${drizzleRelationName}::${rel.direction}`;
+            if (emittedRelationNames.has(deduplicationKey)) continue;
+            emittedRelationNames.add(deduplicationKey);
             if (rel.cardinality === "one") {
               if (rel.direction === "owning" && rel.localKey) {
-                tableRelations.push(`    ${relationKey}: one(${targetTableVar}, {
+                tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {
         fields: [${tableVarName}.${rel.localKey}],
         references: [${targetTableVar}.${getPrimaryKeyName(target)}],
         relationName: "${drizzleRelationName}"
     })`);
               } else if (rel.direction === "inverse" && rel.foreignKeyOnTarget) {
                 const sourceIdField = getPrimaryKeyName(collection);
-                tableRelations.push(`    ${relationKey}: one(${targetTableVar}, {
+                tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {
         fields: [${tableVarName}.${sourceIdField}],
         references: [${targetTableVar}.${rel.foreignKeyOnTarget}],
         relationName: "${drizzleRelationName}"
@@ -8012,7 +8565,7 @@
                   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}, {
+                    tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {
         fields: [${tableVarName}.${sourceIdField}],
         references: [${targetTableVar}.${correspondingRelation.localKey}],
         relationName: "${drizzleRelationName}"
@@ -8024,10 +8577,10 @@
               }
             } else if (rel.cardinality === "many") {
               if (rel.direction === "inverse" && rel.foreignKeyOnTarget) {
-                tableRelations.push(`    ${relationKey}: many(${targetTableVar}, { relationName: "${drizzleRelationName}" })`);
+                tableRelations.push(`    "${relationKey}": many(${targetTableVar}, { relationName: "${drizzleRelationName}" })`);
               } else if (rel.through) {
                 const junctionTableVar = getTableVarName(rel.through.table);
-                tableRelations.push(`    ${relationKey}: many(${junctionTableVar}, { relationName: "${drizzleRelationName}" })`);
+                tableRelations.push(`    "${relationKey}": many(${junctionTableVar}, { relationName: "${drizzleRelationName}" })`);
               } else if (rel.direction === "inverse" && rel.inverseRelationName) {
                 try {
                   const targetCollection = rel.target();
@@ -8035,7 +8588,7 @@
                   const correspondingRelation = Object.values(targetResolvedRelations).find((targetRel) => targetRel.direction === "owning" && targetRel.cardinality === "many" && targetRel.through && targetRel.relationName === rel.inverseRelationName);
                   if (correspondingRelation && correspondingRelation.through) {
                     const junctionTableVar = getTableVarName(correspondingRelation.through.table);
-                    tableRelations.push(`    ${relationKey}: many(${junctionTableVar}, { relationName: "${drizzleRelationName}" })`);
+                    tableRelations.push(`    "${relationKey}": many(${junctionTableVar}, { relationName: "${drizzleRelationName}" })`);
                   } else {
                     console.warn(`Could not find corresponding owning many-to-many relation for inverse relation '${relationKey}' on '${collection.name}'`);
                   }
@@ -8339,6 +8892,14 @@ ${tableRelations.join(",\n")}
     async handleCollectionSubscription(clientId, request, authContext) {
       const subscriptionId = request.subscriptionId;
       try {
+        const collection = this.registry.getCollectionByPath(request.path);
+        if (!collection) {
+          const registered = this.registry.getCollections().map((c) => c.slug).join(", ");
+          const msg = `Collection not found: '${request.path}'. Registered: [${registered}]`;
+          console.error(`[RealtimeService] ${msg}`);
+          this.sendError(clientId, msg, subscriptionId);
+          return;
+        }
         this._subscriptions.set(subscriptionId, {
           clientId,
           type: "collection",
@@ -8356,7 +8917,6 @@ ${tableRelations.join(",\n")}
         });
         let entities;
         if (this.driver) {
-          const collection = this.registry.getCollectionByPath(request.path);
           entities = await this.driver.fetchCollection({
             path: request.path,
             collection,
@@ -8386,6 +8946,14 @@ ${tableRelations.join(",\n")}
     async handleEntitySubscription(clientId, request, authContext) {
       const subscriptionId = request.subscriptionId;
       try {
+        const collection = this.registry.getCollectionByPath(request.path);
+        if (!collection) {
+          const registered = this.registry.getCollections().map((c) => c.slug).join(", ");
+          const msg = `Collection not found: '${request.path}'. Registered: [${registered}]`;
+          console.error(`[RealtimeService] ${msg}`);
+          this.sendError(clientId, msg, subscriptionId);
+          return;
+        }
         this._subscriptions.set(subscriptionId, {
           clientId,
           type: "entity",
@@ -8395,7 +8963,6 @@ ${tableRelations.join(",\n")}
         });
         let entity;
         if (this.driver) {
-          const collection = this.registry.getCollectionByPath(request.path);
           entity = await this.driver.fetchEntity({
             path: request.path,
             entityId: request.entityId,
@@ -8468,13 +9035,13 @@ ${tableRelations.join(",\n")}
       for (const [subscriptionId, subscription] of webSocketSubscriptions) {
         try {
           if (subscription.type === "entity" && notifyPath === originalPath) {
-            if (entity && entity.values?._rebase_invalidated) {
+            if (entity && entity.values && entity.values?._rebase_invalidated) {
               this.debouncedEntityRefetch(subscriptionId, notifyPath, entityId, subscription);
             } else {
               this.sendEntityUpdate(subscription.clientId, subscriptionId, entity);
             }
           } else if (subscription.type === "collection" && subscription.collectionRequest) {
-            if (!entity || !entity.values?._rebase_invalidated) {
+            if (!entity || !(entity.values && entity.values?._rebase_invalidated)) {
               this.sendCollectionEntityPatch(subscription.clientId, subscriptionId, entityId, entity);
             }
             this.debouncedCollectionRefetch(subscriptionId, notifyPath, subscription);
@@ -8489,7 +9056,7 @@ ${tableRelations.join(",\n")}
           const callback = this.subscriptionCallbacks.get(subscriptionId);
           if (!callback) continue;
           if (subscription.type === "entity" && notifyPath === originalPath) {
-            if (entity && entity.values?._rebase_invalidated) {
+            if (entity && entity.values && entity.values?._rebase_invalidated) {
               this.debouncedEntityDriverRefetch(subscriptionId, notifyPath, entityId, subscription, callback);
             } else {
               callback(entity);
@@ -8555,6 +9122,7 @@ ${tableRelations.join(",\n")}
           orderBy: collectionRequest.orderBy,
           order: collectionRequest.order,
           limit: collectionRequest.limit,
+          offset: collectionRequest.offset,
           startAfter: collectionRequest.startAfter,
           searchString: collectionRequest.searchString
         });
@@ -8582,6 +9150,7 @@ ${tableRelations.join(",\n")}
                 orderBy: collectionRequest.orderBy,
                 order: collectionRequest.order,
                 limit: collectionRequest.limit,
+                offset: collectionRequest.offset,
                 startAfter: collectionRequest.startAfter,
                 databaseId: collectionRequest.databaseId
               });
@@ -8642,6 +9211,7 @@ ${tableRelations.join(",\n")}
         orderBy: collectionRequest.orderBy,
         order: collectionRequest.order,
         limit: collectionRequest.limit,
+        offset: collectionRequest.offset,
         startAfter: collectionRequest.startAfter,
         databaseId: collectionRequest.databaseId
       });
@@ -8947,7 +9517,7 @@ ${tableRelations.join(",\n")}
   }
   const PostgresRealtimeProvider = RealtimeService;
   const clientSessions = /* @__PURE__ */ new Map();
-  const WS_RATE_LIMIT = 200;
+  const WS_RATE_LIMIT = 2e3;
   const WS_RATE_WINDOW_MS = 6e4;
   const ADMIN_ONLY_TYPES = /* @__PURE__ */ new Set(["EXECUTE_SQL", "FETCH_DATABASES", "FETCH_ROLES", "FETCH_UNMAPPED_TABLES", "FETCH_TABLE_METADATA", "FETCH_CURRENT_DATABASE", "CREATE_BRANCH", "DELETE_BRANCH", "LIST_BRANCHES"]);
   function isAdminSession(session) {
@@ -8967,6 +9537,12 @@ ${tableRelations.join(",\n")}
     const wss = new ws.WebSocketServer({
       server
     });
+    wss.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        return;
+      }
+      console.error("❌ [WebSocket Server] Error:", err);
+    });
     const requireAuth = authConfig?.requireAuth !== false && authConfig?.jwtSecret;
     wss.on("connection", (ws2) => {
       const clientId = `client_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
@@ -9207,7 +9783,12 @@ ${tableRelations.join(",\n")}
                   options
                 } = payload;
                 const delegate = await getScopedDelegate();
-                const result = await delegate.executeSql(sql, options);
+                const admin = delegate.admin;
+                if (!isSQLAdmin(admin)) {
+                  sendError("ERROR", "NOT_SUPPORTED", "SQL execution is not available for this driver.");
+                  break;
+                }
+                const result = await admin.executeSql(sql, options);
                 if (process.env.NODE_ENV !== "production") {
                   wsDebug(`⚡ [WebSocket Server] SQL executed. Returned ${Array.isArray(result) ? result.length : "non-array"} rows.`);
                 }
@@ -9225,9 +9806,10 @@ ${tableRelations.join(",\n")}
               {
                 wsDebug("📚 [WebSocket Server] Processing FETCH_DATABASES request");
                 const delegate = await getScopedDelegate();
+                const admin = delegate.admin;
                 let databases = [];
-                if (delegate.fetchAvailableDatabases) {
-                  databases = await delegate.fetchAvailableDatabases();
+                if (isSQLAdmin(admin) && admin.fetchAvailableDatabases) {
+                  databases = await admin.fetchAvailableDatabases();
                 }
                 wsDebug(`📚 [WebSocket Server] Fetched ${databases.length} databases.`);
                 const response = {
@@ -9244,9 +9826,10 @@ ${tableRelations.join(",\n")}
               {
                 wsDebug("👤 [WebSocket Server] Processing FETCH_ROLES request");
                 const delegate = await getScopedDelegate();
+                const admin = delegate.admin;
                 let roles2 = [];
-                if (delegate.fetchAvailableRoles) {
-                  roles2 = await delegate.fetchAvailableRoles();
+                if (isSQLAdmin(admin) && admin.fetchAvailableRoles) {
+                  roles2 = await admin.fetchAvailableRoles();
                 }
                 wsDebug(`👤 [WebSocket Server] Fetched ${roles2.length} roles.`);
                 const response = {
@@ -9263,9 +9846,10 @@ ${tableRelations.join(",\n")}
               {
                 wsDebug("📚 [WebSocket Server] Processing FETCH_CURRENT_DATABASE request");
                 const delegate = await getScopedDelegate();
+                const admin = delegate.admin;
                 let database = void 0;
-                if (delegate.fetchCurrentDatabase) {
-                  database = await delegate.fetchCurrentDatabase();
+                if (isSQLAdmin(admin) && admin.fetchCurrentDatabase) {
+                  database = await admin.fetchCurrentDatabase();
                 }
                 const response = {
                   type: "FETCH_CURRENT_DATABASE_SUCCESS",
@@ -9281,9 +9865,10 @@ ${tableRelations.join(",\n")}
               {
                 wsDebug("📋 [WebSocket Server] Processing FETCH_UNMAPPED_TABLES request");
                 const delegate = await getScopedDelegate();
+                const admin = delegate.admin;
                 let tables = [];
-                if (delegate.fetchUnmappedTables) {
-                  tables = await delegate.fetchUnmappedTables(payload?.mappedPaths);
+                if (isSchemaAdmin(admin) && admin.fetchUnmappedTables) {
+                  tables = await admin.fetchUnmappedTables(payload?.mappedPaths);
                 }
                 wsDebug(`📋 [WebSocket Server] Fetched ${tables.length} unmapped tables.`);
                 const response = {
@@ -9303,9 +9888,10 @@ ${tableRelations.join(",\n")}
                   tableName
                 } = payload;
                 const delegate = await getScopedDelegate();
+                const admin = delegate.admin;
                 let metadata;
-                if (delegate.fetchTableMetadata) {
-                  metadata = await delegate.fetchTableMetadata(tableName);
+                if (isSchemaAdmin(admin) && admin.fetchTableMetadata) {
+                  metadata = await admin.fetchTableMetadata(tableName);
                 }
                 wsDebug(`📋 [WebSocket Server] Fetched metadata for table '${tableName}'. (${metadata?.columns?.length ?? 0} columns)`);
                 const response = {
@@ -9490,7 +10076,7 @@ ${tableRelations.join(",\n")}
      */
     getRelationKeysForCollection(collectionPath) {
       const collection = this.getCollectionByPath(collectionPath);
-      if (!collection?.relations) return [];
+      if (!collection || !getDataSourceCapabilities(collection.driver).supportsRelations || !collection.relations) return [];
       return collection.relations.map((r) => r.relationName || r.localKey || "").filter(Boolean);
     }
   }
@@ -9547,8 +10133,6 @@ ${tableRelations.join(",\n")}
                 password_hash TEXT,
                 display_name TEXT,
                 photo_url TEXT,
-                provider TEXT DEFAULT 'email',
-                google_id TEXT UNIQUE,
                 created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
                 updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
             )
@@ -9558,8 +10142,20 @@ ${tableRelations.join(",\n")}
             ON rebase.users(email)
         `);
       await db.execute(drizzleOrm.sql`
-            CREATE INDEX IF NOT EXISTS idx_users_google_id 
-            ON rebase.users(google_id)
+            CREATE TABLE IF NOT EXISTS rebase.user_identities (
+                id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
+                user_id TEXT NOT NULL REFERENCES rebase.users(id) ON DELETE CASCADE,
+                provider TEXT NOT NULL,
+                provider_id TEXT NOT NULL,
+                profile_data JSONB,
+                created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+                updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+                UNIQUE(provider, provider_id)
+            )
+        `);
+      await db.execute(drizzleOrm.sql`
+            CREATE INDEX IF NOT EXISTS idx_user_identities_user 
+            ON rebase.user_identities(user_id)
         `);
       await db.execute(drizzleOrm.sql`
             CREATE TABLE IF NOT EXISTS rebase.roles (
@@ -9572,10 +10168,6 @@ ${tableRelations.join(",\n")}
                 created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
             )
         `);
-      await db.execute(drizzleOrm.sql`
-            ALTER TABLE rebase.roles 
-            ADD COLUMN IF NOT EXISTS collection_permissions JSONB
-        `);
       await db.execute(drizzleOrm.sql`
             CREATE TABLE IF NOT EXISTS rebase.user_roles (
                 user_id TEXT NOT NULL REFERENCES rebase.users(id) ON DELETE CASCADE,
@@ -9607,51 +10199,6 @@ ${tableRelations.join(",\n")}
             CREATE INDEX IF NOT EXISTS idx_refresh_tokens_user 
             ON rebase.refresh_tokens(user_id)
         `);
-      await db.execute(drizzleOrm.sql`
-            ALTER TABLE rebase.refresh_tokens 
-            ADD COLUMN IF NOT EXISTS user_agent TEXT
-        `);
-      await db.execute(drizzleOrm.sql`
-            ALTER TABLE rebase.refresh_tokens 
-            ADD COLUMN IF NOT EXISTS ip_address TEXT
-        `);
-      const constraintCheck = await db.execute(drizzleOrm.sql`
-            SELECT 1 FROM information_schema.table_constraints 
-            WHERE constraint_name = 'unique_device_session' 
-            AND table_schema = 'rebase'
-            AND table_name = 'refresh_tokens'
-        `);
-      if (constraintCheck.rows.length === 0) {
-        try {
-          await db.execute(drizzleOrm.sql`
-                    ALTER TABLE rebase.refresh_tokens
-                    ADD CONSTRAINT unique_device_session UNIQUE (user_id, user_agent, ip_address)
-                `);
-          console.log("✅ Added unique_device_session constraint");
-        } catch (e) {
-          const errorMessage = e instanceof Error ? e.message : String(e);
-          if (errorMessage.includes("could not create unique index")) {
-            console.warn("⚠️ Duplicate sessions found, cleaning up before adding constraint...");
-            await db.execute(drizzleOrm.sql`
-                        DELETE FROM rebase.refresh_tokens a
-                        USING rebase.refresh_tokens b
-                        WHERE a.user_id = b.user_id 
-                        AND COALESCE(a.user_agent, '') = COALESCE(b.user_agent, '')
-                        AND COALESCE(a.ip_address, '') = COALESCE(b.ip_address, '')
-                        AND a.created_at < b.created_at
-                    `);
-            await db.execute(drizzleOrm.sql`
-                        ALTER TABLE rebase.refresh_tokens
-                        ADD CONSTRAINT unique_device_session UNIQUE (user_id, user_agent, ip_address)
-                    `).catch((retryErr) => {
-              const retryMessage = retryErr instanceof Error ? retryErr.message : String(retryErr);
-              console.error("Failed to add unique_device_session constraint after cleanup:", retryMessage);
-            });
-          } else {
-            console.error("Constraint migration issue:", errorMessage);
-          }
-        }
-      }
       await db.execute(drizzleOrm.sql`
             CREATE TABLE IF NOT EXISTS rebase.password_reset_tokens (
                 id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
@@ -9677,18 +10224,7 @@ ${tableRelations.join(",\n")}
                 updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
             )
         `);
-      await db.execute(drizzleOrm.sql`
-            ALTER TABLE rebase.users 
-            ADD COLUMN IF NOT EXISTS email_verified BOOLEAN DEFAULT FALSE
-        `);
-      await db.execute(drizzleOrm.sql`
-            ALTER TABLE rebase.users 
-            ADD COLUMN IF NOT EXISTS email_verification_token TEXT
-        `);
-      await db.execute(drizzleOrm.sql`
-            ALTER TABLE rebase.users 
-            ADD COLUMN IF NOT EXISTS email_verification_sent_at TIMESTAMP WITH TIME ZONE
-        `);
+      await applyInternalMigrations(db);
       await db.execute(drizzleOrm.sql`CREATE SCHEMA IF NOT EXISTS auth`);
       await db.transaction(async (tx) => {
         await tx.execute(drizzleOrm.sql`SELECT pg_advisory_xact_lock(hashtext('rebase_auth_functions_init'))`);
@@ -9741,6 +10277,99 @@ ${tableRelations.join(",\n")}
     }
     console.log("✅ Default roles created: admin, editor, viewer");
   }
+  async function applyInternalMigrations(db) {
+    try {
+      await db.execute(drizzleOrm.sql`
+            ALTER TABLE rebase.users 
+            ADD COLUMN IF NOT EXISTS email_verified BOOLEAN DEFAULT FALSE,
+            ADD COLUMN IF NOT EXISTS email_verification_token TEXT,
+            ADD COLUMN IF NOT EXISTS email_verification_sent_at TIMESTAMP WITH TIME ZONE
+        `);
+      const columnsCheck = await db.execute(drizzleOrm.sql`
+            SELECT column_name 
+            FROM information_schema.columns 
+            WHERE table_schema='rebase' AND table_name='users' AND column_name IN ('google_id', 'linkedin_id', 'provider')
+        `);
+      const existingColumns = columnsCheck.rows.map((r) => r.column_name);
+      if (existingColumns.includes("google_id")) {
+        await db.execute(drizzleOrm.sql`
+                INSERT INTO rebase.user_identities (user_id, provider, provider_id)
+                SELECT id, 'google', google_id
+                FROM rebase.users
+                WHERE google_id IS NOT NULL
+                ON CONFLICT (provider, provider_id) DO NOTHING
+            `);
+      }
+      if (existingColumns.includes("linkedin_id")) {
+        await db.execute(drizzleOrm.sql`
+                INSERT INTO rebase.user_identities (user_id, provider, provider_id)
+                SELECT id, 'linkedin', linkedin_id
+                FROM rebase.users
+                WHERE linkedin_id IS NOT NULL
+                ON CONFLICT (provider, provider_id) DO NOTHING
+            `);
+      }
+      if (existingColumns.length > 0) {
+        await db.execute(drizzleOrm.sql`
+                ALTER TABLE rebase.users
+                DROP COLUMN IF EXISTS provider,
+                DROP COLUMN IF EXISTS google_id,
+                DROP COLUMN IF EXISTS linkedin_id
+            `);
+        await db.execute(drizzleOrm.sql`DROP INDEX IF EXISTS rebase.idx_users_google_id`);
+        await db.execute(drizzleOrm.sql`DROP INDEX IF EXISTS rebase.idx_users_linkedin_id`);
+        console.log("✅ Migrated to user_identities and dropped legacy columns.");
+      }
+      await db.execute(drizzleOrm.sql`
+            ALTER TABLE rebase.roles 
+            ADD COLUMN IF NOT EXISTS collection_permissions JSONB
+        `);
+      await db.execute(drizzleOrm.sql`
+            ALTER TABLE rebase.refresh_tokens 
+            ADD COLUMN IF NOT EXISTS user_agent TEXT,
+            ADD COLUMN IF NOT EXISTS ip_address TEXT
+        `);
+      const constraintCheck = await db.execute(drizzleOrm.sql`
+            SELECT 1 FROM information_schema.table_constraints 
+            WHERE constraint_name = 'unique_device_session' 
+            AND table_schema = 'rebase'
+            AND table_name = 'refresh_tokens'
+        `);
+      if (constraintCheck.rows.length === 0) {
+        try {
+          await db.execute(drizzleOrm.sql`
+                    ALTER TABLE rebase.refresh_tokens
+                    ADD CONSTRAINT unique_device_session UNIQUE (user_id, user_agent, ip_address)
+                `);
+          console.log("✅ Added unique_device_session constraint");
+        } catch (e) {
+          const errorMessage = e instanceof Error ? e.message : String(e);
+          if (errorMessage.includes("could not create unique index")) {
+            console.warn("⚠️ Duplicate sessions found, cleaning up before adding constraint...");
+            await db.execute(drizzleOrm.sql`
+                        DELETE FROM rebase.refresh_tokens a
+                        USING rebase.refresh_tokens b
+                        WHERE a.user_id = b.user_id 
+                        AND COALESCE(a.user_agent, '') = COALESCE(b.user_agent, '')
+                        AND COALESCE(a.ip_address, '') = COALESCE(b.ip_address, '')
+                        AND a.created_at < b.created_at
+                    `);
+            await db.execute(drizzleOrm.sql`
+                        ALTER TABLE rebase.refresh_tokens
+                        ADD CONSTRAINT unique_device_session UNIQUE (user_id, user_agent, ip_address)
+                    `).catch((retryErr) => {
+              const retryMessage = retryErr instanceof Error ? retryErr.message : String(retryErr);
+              console.error("Failed to add unique_device_session constraint after cleanup:", retryMessage);
+            });
+          } else {
+            console.error("Constraint migration issue:", errorMessage);
+          }
+        }
+      }
+    } catch (error) {
+      console.error("❌ Failed to run internal migrations:", error);
+    }
+  }
   class UserService {
     constructor(db) {
       this.db = db;
@@ -9757,9 +10386,54 @@ ${tableRelations.join(",\n")}
       const [user] = await this.db.select().from(users).where(drizzleOrm.eq(users.email, email.toLowerCase()));
       return user || null;
     }
-    async getUserByGoogleId(googleId) {
-      const [user] = await this.db.select().from(users).where(drizzleOrm.eq(users.googleId, googleId));
-      return user || null;
+    async getUserByIdentity(provider, providerId) {
+      const result = await this.db.execute(drizzleOrm.sql`
+            SELECT u.*
+            FROM rebase.users u
+            INNER JOIN rebase.user_identities ui ON u.id = ui.user_id
+            WHERE ui.provider = ${provider} AND ui.provider_id = ${providerId}
+            LIMIT 1
+        `);
+      if (result.rows.length === 0) return null;
+      const row = result.rows[0];
+      return {
+        id: row.id,
+        email: row.email,
+        passwordHash: row.password_hash ?? null,
+        displayName: row.display_name ?? null,
+        photoUrl: row.photo_url ?? null,
+        emailVerified: row.email_verified ?? false,
+        emailVerificationToken: row.email_verification_token ?? null,
+        emailVerificationSentAt: row.email_verification_sent_at ?? null,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+      };
+    }
+    async getUserIdentities(userId) {
+      const result = await this.db.execute(drizzleOrm.sql`
+            SELECT id, user_id, provider, provider_id, profile_data, created_at, updated_at
+            FROM rebase.user_identities
+            WHERE user_id = ${userId}
+        `);
+      return result.rows.map((row) => ({
+        id: row.id,
+        userId: row.user_id,
+        provider: row.provider,
+        providerId: row.provider_id,
+        profileData: row.profile_data ?? null,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+      }));
+    }
+    async linkUserIdentity(userId, provider, providerId, profileData) {
+      await this.db.insert(userIdentities).values({
+        userId,
+        provider,
+        providerId,
+        profileData: profileData || null
+      }).onConflictDoNothing({
+        target: [userIdentities.provider, userIdentities.providerId]
+      });
     }
     async updateUser(id, data) {
       const [user] = await this.db.update(users).set({
@@ -9780,6 +10454,7 @@ ${tableRelations.join(",\n")}
       const search = options?.search?.trim() || "";
       const orderBy = options?.orderBy || "createdAt";
       const orderDir = options?.orderDir || "desc";
+      const roleId = options?.roleId;
       const columnMap = {
         email: "email",
         displayName: "display_name",
@@ -9789,42 +10464,34 @@ ${tableRelations.join(",\n")}
       };
       const orderColumn = columnMap[orderBy] || "created_at";
       const direction = orderDir === "asc" ? drizzleOrm.sql`ASC` : drizzleOrm.sql`DESC`;
-      let rows;
-      let total;
+      const conditions = [];
+      if (roleId) {
+        conditions.push(drizzleOrm.sql`EXISTS (SELECT 1 FROM rebase.user_roles ur WHERE ur.user_id = users.id AND ur.role_id = ${roleId})`);
+      }
       if (search) {
         const pattern = `%${search}%`;
-        const countResult = await this.db.execute(drizzleOrm.sql`
-                SELECT count(*)::int as total FROM rebase.users
-                WHERE email ILIKE ${pattern} OR display_name ILIKE ${pattern}
-            `);
-        total = countResult.rows[0].total;
-        const dataResult = await this.db.execute(drizzleOrm.sql`
-                SELECT * FROM rebase.users
-                WHERE email ILIKE ${pattern} OR display_name ILIKE ${pattern}
-                ORDER BY ${drizzleOrm.sql.raw(orderColumn)} ${direction}
-                LIMIT ${limit} OFFSET ${offset}
-            `);
-        rows = dataResult.rows;
-      } else {
-        const countResult = await this.db.execute(drizzleOrm.sql`
-                SELECT count(*)::int as total FROM rebase.users
-            `);
-        total = countResult.rows[0].total;
-        const dataResult = await this.db.execute(drizzleOrm.sql`
-                SELECT * FROM rebase.users
-                ORDER BY ${drizzleOrm.sql.raw(orderColumn)} ${direction}
-                LIMIT ${limit} OFFSET ${offset}
-            `);
-        rows = dataResult.rows;
+        conditions.push(drizzleOrm.sql`(email ILIKE ${pattern} OR display_name ILIKE ${pattern})`);
       }
+      const whereClause = conditions.length > 0 ? drizzleOrm.sql`WHERE ${drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `)}` : drizzleOrm.sql``;
+      const orderByClause = roleId ? drizzleOrm.sql`ORDER BY ${drizzleOrm.sql.raw(orderColumn)} ${direction}` : drizzleOrm.sql`ORDER BY (SELECT count(*) FROM rebase.user_roles ur WHERE ur.user_id = users.id) DESC, ${drizzleOrm.sql.raw(orderColumn)} ${direction}`;
+      const countResult = await this.db.execute(drizzleOrm.sql`
+            SELECT count(*)::int as total FROM rebase.users
+            ${whereClause}
+        `);
+      const total = countResult.rows[0].total;
+      const dataResult = await this.db.execute(drizzleOrm.sql`
+            SELECT * FROM rebase.users
+            ${whereClause}
+            ${orderByClause}
+            LIMIT ${limit} OFFSET ${offset}
+        `);
+      const rows = dataResult.rows;
       const mappedUsers = rows.map((row) => ({
         id: row.id,
         email: row.email,
         passwordHash: row.password_hash ?? row.passwordHash ?? null,
         displayName: row.display_name ?? row.displayName ?? null,
         photoUrl: row.photo_url ?? row.photoUrl ?? null,
-        provider: row.provider,
-        googleId: row.google_id ?? row.googleId ?? null,
         emailVerified: row.email_verified ?? row.emailVerified ?? false,
         emailVerificationToken: row.email_verification_token ?? row.emailVerificationToken ?? null,
         emailVerificationSentAt: row.email_verification_sent_at ?? row.emailVerificationSentAt ?? null,
@@ -10198,8 +10865,14 @@ ${tableRelations.join(",\n")}
     async getUserByEmail(email) {
       return this.userService.getUserByEmail(email);
     }
-    async getUserByGoogleId(googleId) {
-      return this.userService.getUserByGoogleId(googleId);
+    async getUserByIdentity(provider, providerId) {
+      return this.userService.getUserByIdentity(provider, providerId);
+    }
+    async getUserIdentities(userId) {
+      return this.userService.getUserIdentities(userId);
+    }
+    async linkUserIdentity(userId, provider, providerId, profileData) {
+      return this.userService.linkUserIdentity(userId, provider, providerId, profileData);
     }
     async updateUser(id, data) {
       return this.userService.updateUser(id, data);
@@ -10327,16 +11000,6 @@ ${tableRelations.join(",\n")}
         updatedBy
       } = params;
       const changedFields = previousValues && values ? findChangedFields(previousValues, values) : null;
-      try {
-        require("fs").appendFileSync("/Users/francesco/rebase/packages/backend/history_diff.log", `[recordHistory: ${tableName}/${entityId} - ${action}]
-CHANGED FIELDS: ${JSON.stringify(changedFields)}
-PREVIOUS: ${JSON.stringify(previousValues, null, 2)}
-NEW:      ${JSON.stringify(values, null, 2)}
-
-`);
-      } catch (e) {
-        console.error("DEBUG FILE WRITE ERROR:", e);
-      }
       if (action === "update" && (!changedFields || changedFields.length === 0)) {
         return;
       }
@@ -10498,6 +11161,7 @@ NEW:      ${JSON.stringify(values, null, 2)}
         const registry = new PostgresCollectionRegistry();
         if (collections) {
           registry.registerMultiple(collections);
+          console.log(`📋 [PostgresRegistry] Registered ${registry.getCollections().length} collections: [${registry.getCollections().map((c) => c.slug).join(", ")}]`);
         }
         if (pgConfig.schema?.tables) {
           Object.values(pgConfig.schema.tables).forEach((table) => {
@@ -10564,9 +11228,6 @@ NEW:      ${JSON.stringify(values, null, 2)}
         const internals = driverResult.internals;
         const db = internals.db;
         await ensureAuthTablesExist(db);
-        if (authConfig.google?.clientId) {
-          serverCore.configureGoogleOAuth(authConfig.google.clientId);
-        }
         let emailService;
         if (authConfig.email) {
           emailService = serverCore.createEmailService(authConfig.email);
@@ -10634,6 +11295,8 @@ NEW:      ${JSON.stringify(values, null, 2)}
   exports2.refreshTokensRelations = refreshTokensRelations;
   exports2.roles = roles;
   exports2.rolesRelations = rolesRelations;
+  exports2.userIdentities = userIdentities;
+  exports2.userIdentitiesRelations = userIdentitiesRelations;
   exports2.userRoles = userRoles;
   exports2.userRolesRelations = userRolesRelations;
   exports2.users = users;