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

package/dist/index.es.js

@@ -2,6 +2,7 @@ import { Pool, Client } from "pg";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { sql, inArray, eq as eq$3, and, or, ilike, asc, desc, gt, lt, getTableName as getTableName$1, count, relations, isTable } from "drizzle-orm";
 import { pgSchema, timestamp, varchar, boolean, uuid, jsonb, primaryKey, unique } from "drizzle-orm/pg-core";
+import { createHash, randomUUID } from "crypto";
 import * as fs from "fs";
 import { promises } from "fs";
 import path from "path";
@@ -9,67 +10,120 @@ import { pathToFileURL } from "url";
 import chokidar from "chokidar";
 import { WebSocket, WebSocketServer } from "ws";
 import { EventEmitter } from "events";
-import { randomUUID } from "crypto";
 import { inspect } from "util";
-import { extractUserFromToken, configureGoogleOAuth, createEmailService } from "@rebasepro/server-core";
-function createPostgresDatabaseConnection(connectionString, schema) {
-  const pool = new Pool({
+import { extractUserFromToken, createEmailService } from "@rebasepro/server-core";
+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 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 ? drizzle(pool, {
     schema
   }) : 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);
@@ -967,6 +1021,21 @@ function generateForeignKeyName(name) {
   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;
@@ -990,15 +1059,35 @@ function getSubcollections(collection) {
   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 [];
 }
@@ -1105,7 +1194,7 @@ function sanitizeRelation(relation, sourceCollection) {
       if (!newRelation.foreignKeyOnTarget) {
         let foundForeignKey = false;
         try {
-          const targetRelations = targetCollection.relations || [];
+          const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? targetCollection.relations || [] : [];
           for (const targetRel of targetRelations) {
             if (targetRel.direction === "owning" && targetRel.cardinality === "one" && targetRel.localKey) {
               try {
@@ -1131,7 +1220,7 @@ function sanitizeRelation(relation, sourceCollection) {
       let isManyToManyInverse = false;
       if (newRelation.inverseRelationName && !newRelation.foreignKeyOnTarget) {
         try {
-          const targetRelations = targetCollection.relations || [];
+          const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? targetCollection.relations || [] : [];
           for (const targetRel of targetRelations) {
             if (targetRel.cardinality === "many" && (targetRel.direction === "owning" || !targetRel.direction) && targetRel.relationName === newRelation.inverseRelationName) {
               isManyToManyInverse = true;
@@ -1165,14 +1254,21 @@ function sanitizeRelation(relation, sourceCollection) {
   }
   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 relations2 = {};
-  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) {
         relations2[relationKey] = normalizedRelation;
+        registeredRelationNames.add(relationKey);
       }
     });
   }
@@ -1184,15 +1280,17 @@ function resolveCollectionRelations(collection) {
         sourceCollection: collection
       });
       if (relation) {
-        if (!relations2[propKey]) {
-          if (!relation.relationName) {
-            relation.relationName = propKey;
-          }
-          relations2[propKey] = sanitizeRelation(relation, collection);
+        if (relations2[propKey]) return;
+        if (!relation.relationName) {
+          relation.relationName = propKey;
         }
+        const normalizedRelation = sanitizeRelation(relation, collection);
+        relations2[propKey] = normalizedRelation;
+        registeredRelationNames.add(normalizedRelation.relationName ?? propKey);
       }
     });
   }
+  _resolvedRelationsCache.set(collection, relations2);
   return relations2;
 }
 function resolvePropertyRelation({
@@ -1201,7 +1299,24 @@ function resolvePropertyRelation({
   sourceCollection
 }) {
   if (property.type !== "relation") return void 0;
-  const relation = (sourceCollection.relations ?? []).find((rel) => rel.relationName === property.relationName);
+  const relProp = property;
+  if (relProp.target) {
+    return {
+      relationName: relProp.relationName || propertyKey,
+      target: relProp.target,
+      cardinality: relProp.cardinality || "one",
+      direction: relProp.direction || "owning",
+      inverseRelationName: relProp.inverseRelationName,
+      localKey: relProp.localKey,
+      foreignKeyOnTarget: relProp.foreignKeyOnTarget,
+      through: relProp.through,
+      joinPath: relProp.joinPath,
+      onUpdate: relProp.onUpdate,
+      onDelete: relProp.onDelete,
+      overrides: relProp.overrides
+    };
+  }
+  const relation = (sourceCollection.relations ?? []).find((rel) => rel.relationName === relProp.relationName);
   if (!relation) {
     console.warn(`Unrecognized relation format for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
     return void 0;
@@ -1209,7 +1324,7 @@ function resolvePropertyRelation({
   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);
@@ -1225,6 +1340,14 @@ function getEnumVarName(tableName, propName) {
 function getColumnName(fullColumn) {
   return fullColumn.includes(".") ? fullColumn.split(".").pop() : fullColumn;
 }
+function findRelation(resolvedRelations, key) {
+  if (resolvedRelations[key]) return resolvedRelations[key];
+  const slugKey = key.replace(/_/g, "-");
+  if (slugKey !== key && resolvedRelations[slugKey]) return resolvedRelations[slugKey];
+  const snakeKey = key.replace(/-/g, "_");
+  if (snakeKey !== key && resolvedRelations[snakeKey]) return resolvedRelations[snakeKey];
+  return void 0;
+}
 var logic = { exports: {} };
 (function(module, exports$1) {
   (function(root2, factory) {
@@ -2997,10 +3120,12 @@ class CollectionRegistry {
   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;
@@ -3013,9 +3138,11 @@ class CollectionRegistry {
     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.
@@ -3048,12 +3175,14 @@ class CollectionRegistry {
         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$1(rawSubcollections[subIndex]));
+      if (subcollections && subcollections.length > 0) {
+        subcollections.forEach((subCollection) => {
+          if (!subCollection) return;
+          this._registerRecursively(this.normalizeCollection({
+            ...subCollection
+          }), cloneDeep$1(subCollection));
         });
       }
     });
@@ -3079,41 +3208,100 @@ class CollectionRegistry {
     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$1(rawSubcollections[index]));
+    const subcollections = getSubcollections(normalizedCollection);
+    if (subcollections && subcollections.length > 0) {
+      subcollections.forEach((subCollection) => {
+        if (!subCollection) return;
+        this._registerRecursively(this.normalizeCollection({
+          ...subCollection
+        }), cloneDeep$1(subCollection));
       });
     }
   }
   normalizeCollection(collection) {
-    const relations2 = isPostgresCollection(collection) ? collection.relations ?? [] : [];
-    const properties = this.normalizeProperties(collection.properties, relations2);
-    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 relations2 = [];
+    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;
+          relations2.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) {
+        relations2.push(...this.extractRelationsFromProperties(property.properties));
+      }
+    }
+    return relations2;
   }
   normalizeProperties(properties, relations2) {
     const newProperties = {};
     for (const key in properties) {
-      newProperties[key] = this.normalizeProperty(properties[key], relations2);
+      newProperties[key] = this.normalizeProperty(key, properties[key], relations2);
     }
     return newProperties;
   }
-  normalizeProperty(property, relations2) {
+  normalizeProperty(key, property, relations2) {
     const newProperty = {
       ...property
     };
@@ -3123,9 +3311,9 @@ class CollectionRegistry {
       const arrayProp = newProperty;
       if (arrayProp.of) {
         if (Array.isArray(arrayProp.of)) {
-          arrayProp.of = arrayProp.of.map((p) => this.normalizeProperty(p, relations2));
+          arrayProp.of = arrayProp.of.map((p, i) => this.normalizeProperty(`${key}[${i}]`, p, relations2));
         } else {
-          arrayProp.of = this.normalizeProperty(arrayProp.of, relations2);
+          arrayProp.of = this.normalizeProperty(`${key}.of`, arrayProp.of, relations2);
         }
       } else if (arrayProp.oneOf && arrayProp.oneOf.properties) {
         arrayProp.oneOf.properties = this.normalizeProperties(arrayProp.oneOf.properties, relations2);
@@ -3137,11 +3325,12 @@ class CollectionRegistry {
       }
     } else if (newProperty.type === "relation") {
       const relationProperty = newProperty;
-      const relation = relations2.find((r) => r.relationName === relationProperty.relationName);
+      const name = relationProperty.relationName || key;
+      const relation = relations2.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;
@@ -3149,6 +3338,11 @@ class CollectionRegistry {
   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);
   }
   /**
@@ -3158,6 +3352,11 @@ class CollectionRegistry {
   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);
   }
   /**
@@ -3179,11 +3378,11 @@ class CollectionRegistry {
     }
     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}'`);
       }
@@ -3193,10 +3392,16 @@ class CollectionRegistry {
     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
@@ -3252,24 +3457,62 @@ function convertWhereToFilter(where) {
     "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;
@@ -3288,7 +3531,7 @@ function createDriverAccessor(driver, slug) {
       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],
@@ -3350,7 +3593,7 @@ function createDriverAccessor(driver, slug) {
       return driver.listenCollection({
         path: slug,
         limit: params?.limit,
-        startAfter: params?.offset,
+        offset: params?.offset,
         filter: convertWhereToFilter(params?.where),
         orderBy: orderParsed?.[0],
         order: orderParsed?.[1],
@@ -3397,7 +3640,8 @@ function buildRebaseData(driver) {
       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);
     }
   });
 }
@@ -3455,7 +3699,7 @@ class DrizzleConditionBuilder {
    * 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,
@@ -3467,7 +3711,7 @@ class DrizzleConditionBuilder {
     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
@@ -3475,37 +3719,37 @@ class DrizzleConditionBuilder {
       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
     });
@@ -3756,7 +4000,8 @@ class DrizzleConditionBuilder {
   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(ilike(fieldColumn, `%${searchString}%`));
@@ -3919,29 +4164,29 @@ class DrizzleConditionBuilder {
     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,
@@ -3950,7 +4195,7 @@ class DrizzleConditionBuilder {
         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);
@@ -3959,10 +4204,19 @@ class DrizzleConditionBuilder {
   }
 }
 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;
 }
@@ -3979,7 +4233,8 @@ function getPrimaryKeys(collection, registry) {
   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;
@@ -3989,19 +4244,25 @@ function getPrimaryKeys(collection, registry) {
   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;
@@ -4013,7 +4274,7 @@ function parseIdValues(idValue, primaryKeys) {
   }
   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}`);
@@ -4031,7 +4292,7 @@ function parseIdValues(idValue, primaryKeys) {
   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}`);
@@ -4090,28 +4351,37 @@ function sanitizeAndConvertDates(obj) {
   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,
@@ -4121,7 +4391,7 @@ function serializeDataToServer(entity, properties, collection, registry) {
           });
           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,
@@ -4139,7 +4409,7 @@ function serializeDataToServer(entity, properties, collection, registry) {
           }
           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,
@@ -4149,15 +4419,13 @@ function serializeDataToServer(entity, properties, collection, registry) {
         }
       }
     }
-    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) {
@@ -4171,10 +4439,28 @@ function serializePropertyToServer(value, property) {
       } 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":
@@ -4198,38 +4484,20 @@ function serializePropertyToServer(value, property) {
 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);
             }
@@ -4248,18 +4516,10 @@ async function parseDataFromServer(data, collection, db, registry) {
                   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));
                   }
                 }
               }
@@ -4320,19 +4580,11 @@ async function parseDataFromServer(data, collection, db, registry) {
                 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);
                   });
                 }
               }
@@ -4356,7 +4608,7 @@ function parsePropertyFromServer(value, property, collection, propertyKey) {
         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);
@@ -4367,11 +4619,7 @@ function parsePropertyFromServer(value, property, collection, propertyKey) {
         }
         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;
@@ -4379,8 +4627,25 @@ function parsePropertyFromServer(value, property, collection, propertyKey) {
       }
       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":
@@ -4425,11 +4690,8 @@ function parsePropertyFromServer(value, property, collection, propertyKey) {
       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]) {
@@ -4437,14 +4699,25 @@ function normalizeDbValues(data, collection) {
     }
   });
   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;
@@ -4456,9 +4729,10 @@ class RelationService {
   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);
   }
@@ -4558,8 +4832,11 @@ class RelationService {
   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);
@@ -4624,16 +4901,59 @@ class RelationService {
       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(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(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();
@@ -4651,7 +4971,8 @@ class RelationService {
     );
     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) {
@@ -4659,22 +4980,133 @@ class RelationService {
       } 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, eq$3(fromCol, toCol));
+        currentTable = joinTable;
+      }
+      const parentIdField = parentTable[getPrimaryKeys(parentCollection, this.registry)[0].fieldName];
+      query2 = query2.where(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, eq$3(targetJunctionCol, targetIdField)).where(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;
   }
   /**
@@ -4683,7 +5115,7 @@ class RelationService {
   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();
@@ -4767,6 +5199,8 @@ class RelationService {
             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);
@@ -5144,6 +5578,20 @@ class EntityFetchService {
   // =============================================================
   // 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.
@@ -5156,12 +5604,10 @@ class EntityFetchService {
    */
   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;
@@ -5211,10 +5657,8 @@ class EntityFetchService {
    */
   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;
@@ -5233,17 +5677,12 @@ class EntityFetchService {
           }
           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();
@@ -5253,17 +5692,12 @@ class EntityFetchService {
         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 {
@@ -5280,27 +5714,16 @@ class EntityFetchService {
    */
   async resolveJoinPathRelations(entity, collection, collectionPath, parsedId, databaseId) {
     const resolvedRelations = resolveCollectionRelations(collection);
-    const propertyKeys = new Set(Object.keys(collection.properties || {}));
-    const promises2 = Object.entries(resolvedRelations).filter(([key, relation]) => propertyKeys.has(key) && relation.joinPath && relation.joinPath.length > 0).map(async ([key, relation]) => {
+    const promises2 = 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);
@@ -5315,8 +5738,7 @@ class EntityFetchService {
   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 {
@@ -5328,15 +5750,10 @@ class EntityFetchService {
         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);
             }
           }
         }
@@ -5346,22 +5763,72 @@ class EntityFetchService {
     }
   }
   /**
-   * 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
@@ -5407,7 +5874,7 @@ class EntityFetchService {
       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) {
@@ -5415,7 +5882,8 @@ class EntityFetchService {
     }
     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" ? asc(orderByField) : desc(orderByField));
       }
@@ -5426,16 +5894,18 @@ class EntityFetchService {
     }
     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];
@@ -5497,11 +5967,7 @@ class EntityFetchService {
     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 {
@@ -5510,11 +5976,7 @@ class EntityFetchService {
             });
             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);
@@ -5544,13 +6006,13 @@ class EntityFetchService {
     }
     const tableName = getTableName$1(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);
@@ -5573,7 +6035,7 @@ class EntityFetchService {
     }
     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" ? asc(orderByField) : desc(orderByField));
       }
@@ -5581,7 +6043,7 @@ class EntityFetchService {
     orderExpressions.push(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);
@@ -5590,6 +6052,7 @@ class EntityFetchService {
     }
     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);
   }
@@ -5603,7 +6066,7 @@ class EntityFetchService {
   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,
@@ -5628,37 +6091,29 @@ class EntityFetchService {
           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,
@@ -5699,12 +6154,16 @@ class EntityFetchService {
     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];
@@ -5726,11 +6185,19 @@ class EntityFetchService {
     let query = this.db.select({
       count: 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(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);
@@ -5749,7 +6216,7 @@ class EntityFetchService {
     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`);
       }
@@ -5808,12 +6275,14 @@ class EntityFetchService {
     const idField = table[idInfo.fieldName];
     const tableName = getTableName$1(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);
       }
@@ -5835,7 +6304,7 @@ class EntityFetchService {
         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,
@@ -5891,7 +6360,9 @@ class EntityFetchService {
           } : {}
         });
         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);
       }
@@ -5959,7 +6430,7 @@ class EntityFetchService {
     }
     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" ? asc(orderByField) : desc(orderByField));
       }
@@ -5968,6 +6439,7 @@ class EntityFetchService {
     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;
   }
   /**
@@ -6016,7 +6488,7 @@ class EntityFetchService {
         }
       }
       if (options.orderBy) {
-        const orderByField = table[options.orderBy];
+        const orderByField = this.resolveOrderByField(table, options.orderBy, collection);
         if (orderByField) {
           queryOpts.orderBy = options.order === "asc" ? asc(orderByField) : desc(orderByField);
         }
@@ -6070,17 +6542,15 @@ class EntityFetchService {
    * 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 {
@@ -6116,6 +6586,7 @@ class EntityPersistService {
     const effectiveValues = {
       ...values
     };
+    let junctionTableInfo;
     if (collectionPath.includes("/")) {
       const segments = collectionPath.split("/").filter(Boolean);
       if (segments.length >= 3 && segments.length % 2 === 1) {
@@ -6125,9 +6596,10 @@ class EntityPersistService {
         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();
@@ -6137,7 +6609,7 @@ class EntityPersistService {
               const parentIdInfo2 = parentIdInfoArray2[0];
               const parsedParentIdObj2 = parseIdValues(currentEntityId, parentIdInfoArray2);
               const parsedParentId2 = parsedParentIdObj2[parentIdInfo2.fieldName];
-              effectiveValues.__junction_table_info = {
+              junctionTableInfo = {
                 parentCollection: currentCollection,
                 parentId: parsedParentId2,
                 relation,
@@ -6206,14 +6678,10 @@ class EntityPersistService {
         }
       }
     }
-    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) => {
@@ -6226,7 +6694,7 @@ class EntityPersistService {
           }
           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];
@@ -6590,21 +7058,6 @@ class PostgresBackendDriver {
     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;
@@ -6622,8 +7075,26 @@ class PostgresBackendDriver {
   _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,
@@ -6652,6 +7123,7 @@ class PostgresBackendDriver {
     collection,
     filter,
     limit,
+    offset,
     startAfter,
     orderBy,
     searchString,
@@ -6662,6 +7134,7 @@ class PostgresBackendDriver {
       orderBy,
       order,
       limit,
+      offset,
       startAfter,
       databaseId: collection?.databaseId,
       searchString
@@ -6705,6 +7178,7 @@ class PostgresBackendDriver {
     collection,
     filter,
     limit,
+    offset,
     startAfter,
     orderBy,
     searchString,
@@ -6725,6 +7199,7 @@ class PostgresBackendDriver {
         orderBy,
         order,
         limit,
+        offset,
         startAfter,
         databaseId: collection?.databaseId,
         searchString
@@ -6736,6 +7211,7 @@ class PostgresBackendDriver {
       collection,
       filter,
       limit,
+      offset,
       startAfter,
       orderBy,
       searchString,
@@ -6896,7 +7372,7 @@ class PostgresBackendDriver {
             collection: resolvedCollection,
             path: path2,
             entityId: savedEntity.id,
-            values: updatedValues,
+            values: savedEntity.values,
             previousValues: previousValuesForHistory,
             status,
             context: contextForCallback
@@ -6907,7 +7383,7 @@ class PostgresBackendDriver {
             collection: resolvedCollection,
             path: path2,
             entityId: savedEntity.id,
-            values: updatedValues,
+            values: savedEntity.values,
             previousValues: previousValuesForHistory,
             status,
             context: contextForCallback
@@ -7044,10 +7520,12 @@ class PostgresBackendDriver {
   async countEntities({
     path: path2,
     collection,
-    filter
+    filter,
+    searchString
   }) {
     return this.entityService.countEntities(path2, {
-      filter
+      filter,
+      searchString
     });
   }
   getTargetDb(databaseName) {
@@ -7103,7 +7581,7 @@ class PostgresBackendDriver {
     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() {
@@ -7277,12 +7755,12 @@ class AuthenticatedPostgresBackendDriver {
     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(",");
@@ -7352,29 +7830,6 @@ class AuthenticatedPostgresBackendDriver {
   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();
@@ -7410,7 +7865,10 @@ class DatabasePoolManager {
       connectionString: url.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);
@@ -7461,13 +7919,6 @@ const users = rebaseSchema.table("users", {
   photoUrl: varchar("photo_url", {
     length: 500
   }),
-  provider: varchar("provider", {
-    length: 50
-  }).notNull().default("email"),
-  // 'email' | 'google'
-  googleId: varchar("google_id", {
-    length: 255
-  }).unique(),
   emailVerified: boolean("email_verified").default(false).notNull(),
   emailVerificationToken: varchar("email_verification_token", {
     length: 255
@@ -7541,12 +7992,31 @@ const appConfig = rebaseSchema.table("app_config", {
   value: jsonb("value").notNull(),
   updatedAt: timestamp("updated_at").defaultNow().notNull()
 });
+const userIdentities = rebaseSchema.table("user_identities", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  userId: uuid("user_id").notNull().references(() => users.id, {
+    onDelete: "cascade"
+  }),
+  provider: varchar("provider", {
+    length: 50
+  }).notNull(),
+  // e.g. 'google', 'linkedin'
+  providerId: varchar("provider_id", {
+    length: 255
+  }).notNull(),
+  profileData: jsonb("profile_data"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => ({
+  uniqueProviderId: unique("unique_provider_id").on(table.provider, table.providerId)
+}));
 const usersRelations = relations(users, ({
   many
 }) => ({
   userRoles: many(userRoles),
   refreshTokens: many(refreshTokens),
-  passwordResetTokens: many(passwordResetTokens)
+  passwordResetTokens: many(passwordResetTokens),
+  userIdentities: many(userIdentities)
 }));
 const rolesRelations = relations(roles, ({
   many
@@ -7581,13 +8051,24 @@ const passwordResetTokensRelations = relations(passwordResetTokens, ({
     references: [users.id]
   })
 }));
+const userIdentitiesRelations = 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
       };
     }
   }
@@ -7595,12 +8076,15 @@ const getPrimaryKeyProp = (collection) => {
   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) => {
@@ -7614,7 +8098,7 @@ const isIdProperty = (propName, prop, collection) => {
   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) {
@@ -7633,20 +8117,20 @@ const getDrizzleColumn = (propName, prop, collection) => {
         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;
     }
@@ -7668,10 +8152,10 @@ const getDrizzleColumn = (propName, prop, collection) => {
         columnDefinition = baseType;
       }
       if (isId) {
-        columnDefinition += `.primaryKey()`;
+        columnDefinition += ".primaryKey()";
       }
       if (numProp.validation?.unique) {
-        columnDefinition += `.unique()`;
+        columnDefinition += ".unique()";
       }
       break;
     }
@@ -7702,7 +8186,7 @@ const getDrizzleColumn = (propName, prop, collection) => {
     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;
       }
@@ -7721,8 +8205,9 @@ const getDrizzleColumn = (propName, prop, collection) => {
       }
       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");
@@ -7735,6 +8220,26 @@ const getDrizzleColumn = (propName, prop, collection) => {
       }
       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;
   }
@@ -7761,7 +8266,7 @@ const buildUsingClause = (rule) => {
     return resolveRawSql(rule.using);
   }
   if (rule.access === "public") {
-    return `sql\`true\``;
+    return "sql`true`";
   }
   if (rule.ownerField) {
     return `sql\`\${table.${rule.ownerField}} = auth.uid()\``;
@@ -7774,16 +8279,31 @@ const buildWithCheckClause = (rule) => {
   }
   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 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;
@@ -7803,22 +8323,57 @@ const generateSinglePolicyCode = (tableName, rule, operation, policyName) => {
     }
   }
   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"));
@@ -7826,9 +8381,7 @@ const generateSchema = async (collections) => {
   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 = [];
@@ -7889,8 +8442,8 @@ const generateSchema = async (collections) => {
       } = 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}", {
@@ -7899,31 +8452,28 @@ const generateSchema = async (collections) => {
 `;
       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 {
@@ -7963,13 +8513,13 @@ const generateSchema = async (collections) => {
           }
         } 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}"
@@ -7977,22 +8527,25 @@ const generateSchema = async (collections) => {
       }
     } 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}"
@@ -8004,7 +8557,7 @@ const generateSchema = async (collections) => {
                 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}"
@@ -8016,10 +8569,10 @@ const generateSchema = async (collections) => {
             }
           } 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();
@@ -8027,7 +8580,7 @@ const generateSchema = async (collections) => {
                 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}'`);
                 }
@@ -8331,6 +8884,14 @@ class RealtimeService extends EventEmitter {
   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",
@@ -8348,7 +8909,6 @@ class RealtimeService extends EventEmitter {
       });
       let entities;
       if (this.driver) {
-        const collection = this.registry.getCollectionByPath(request.path);
         entities = await this.driver.fetchCollection({
           path: request.path,
           collection,
@@ -8378,6 +8938,14 @@ class RealtimeService extends EventEmitter {
   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",
@@ -8387,7 +8955,6 @@ class RealtimeService extends EventEmitter {
       });
       let entity;
       if (this.driver) {
-        const collection = this.registry.getCollectionByPath(request.path);
         entity = await this.driver.fetchEntity({
           path: request.path,
           entityId: request.entityId,
@@ -8460,13 +9027,13 @@ class RealtimeService extends EventEmitter {
     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);
@@ -8481,7 +9048,7 @@ class RealtimeService extends EventEmitter {
         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);
@@ -8547,6 +9114,7 @@ class RealtimeService extends EventEmitter {
         orderBy: collectionRequest.orderBy,
         order: collectionRequest.order,
         limit: collectionRequest.limit,
+        offset: collectionRequest.offset,
         startAfter: collectionRequest.startAfter,
         searchString: collectionRequest.searchString
       });
@@ -8574,6 +9142,7 @@ class RealtimeService extends EventEmitter {
               orderBy: collectionRequest.orderBy,
               order: collectionRequest.order,
               limit: collectionRequest.limit,
+              offset: collectionRequest.offset,
               startAfter: collectionRequest.startAfter,
               databaseId: collectionRequest.databaseId
             });
@@ -8634,6 +9203,7 @@ class RealtimeService extends EventEmitter {
       orderBy: collectionRequest.orderBy,
       order: collectionRequest.order,
       limit: collectionRequest.limit,
+      offset: collectionRequest.offset,
       startAfter: collectionRequest.startAfter,
       databaseId: collectionRequest.databaseId
     });
@@ -8939,7 +9509,7 @@ class RealtimeService extends EventEmitter {
 }
 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) {
@@ -8959,6 +9529,12 @@ function createPostgresWebSocket(server, realtimeService, driver, authConfig) {
   const wss = new 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", (ws) => {
     const clientId = `client_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
@@ -9199,7 +9775,12 @@ function createPostgresWebSocket(server, realtimeService, driver, authConfig) {
                 options
               } = payload;
               const delegate = await getScopedDelegate();
-              const result = await delegate.executeSql(sql2, 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(sql2, options);
               if (process.env.NODE_ENV !== "production") {
                 wsDebug(`⚡ [WebSocket Server] SQL executed. Returned ${Array.isArray(result) ? result.length : "non-array"} rows.`);
               }
@@ -9217,9 +9798,10 @@ function createPostgresWebSocket(server, realtimeService, driver, authConfig) {
             {
               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 = {
@@ -9236,9 +9818,10 @@ function createPostgresWebSocket(server, realtimeService, driver, authConfig) {
             {
               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 = {
@@ -9255,9 +9838,10 @@ function createPostgresWebSocket(server, realtimeService, driver, authConfig) {
             {
               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",
@@ -9273,9 +9857,10 @@ function createPostgresWebSocket(server, realtimeService, driver, authConfig) {
             {
               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 = {
@@ -9295,9 +9880,10 @@ function createPostgresWebSocket(server, realtimeService, driver, authConfig) {
                 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 = {
@@ -9482,7 +10068,7 @@ class PostgresCollectionRegistry extends CollectionRegistry {
    */
   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);
   }
 }
@@ -9539,8 +10125,6 @@ async function ensureAuthTablesExist(db) {
                 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()
             )
@@ -9550,8 +10134,20 @@ async function ensureAuthTablesExist(db) {
             ON rebase.users(email)
         `);
     await db.execute(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(sql`
+            CREATE INDEX IF NOT EXISTS idx_user_identities_user 
+            ON rebase.user_identities(user_id)
         `);
     await db.execute(sql`
             CREATE TABLE IF NOT EXISTS rebase.roles (
@@ -9564,10 +10160,6 @@ async function ensureAuthTablesExist(db) {
                 created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
             )
         `);
-    await db.execute(sql`
-            ALTER TABLE rebase.roles 
-            ADD COLUMN IF NOT EXISTS collection_permissions JSONB
-        `);
     await db.execute(sql`
             CREATE TABLE IF NOT EXISTS rebase.user_roles (
                 user_id TEXT NOT NULL REFERENCES rebase.users(id) ON DELETE CASCADE,
@@ -9599,51 +10191,6 @@ async function ensureAuthTablesExist(db) {
             CREATE INDEX IF NOT EXISTS idx_refresh_tokens_user 
             ON rebase.refresh_tokens(user_id)
         `);
-    await db.execute(sql`
-            ALTER TABLE rebase.refresh_tokens 
-            ADD COLUMN IF NOT EXISTS user_agent TEXT
-        `);
-    await db.execute(sql`
-            ALTER TABLE rebase.refresh_tokens 
-            ADD COLUMN IF NOT EXISTS ip_address TEXT
-        `);
-    const constraintCheck = await db.execute(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(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(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(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(sql`
             CREATE TABLE IF NOT EXISTS rebase.password_reset_tokens (
                 id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
@@ -9669,18 +10216,7 @@ async function ensureAuthTablesExist(db) {
                 updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
             )
         `);
-    await db.execute(sql`
-            ALTER TABLE rebase.users 
-            ADD COLUMN IF NOT EXISTS email_verified BOOLEAN DEFAULT FALSE
-        `);
-    await db.execute(sql`
-            ALTER TABLE rebase.users 
-            ADD COLUMN IF NOT EXISTS email_verification_token TEXT
-        `);
-    await db.execute(sql`
-            ALTER TABLE rebase.users 
-            ADD COLUMN IF NOT EXISTS email_verification_sent_at TIMESTAMP WITH TIME ZONE
-        `);
+    await applyInternalMigrations(db);
     await db.execute(sql`CREATE SCHEMA IF NOT EXISTS auth`);
     await db.transaction(async (tx) => {
       await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext('rebase_auth_functions_init'))`);
@@ -9733,6 +10269,99 @@ async function seedDefaultRoles(db) {
   }
   console.log("✅ Default roles created: admin, editor, viewer");
 }
+async function applyInternalMigrations(db) {
+  try {
+    await db.execute(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(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(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(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(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(sql`DROP INDEX IF EXISTS rebase.idx_users_google_id`);
+      await db.execute(sql`DROP INDEX IF EXISTS rebase.idx_users_linkedin_id`);
+      console.log("✅ Migrated to user_identities and dropped legacy columns.");
+    }
+    await db.execute(sql`
+            ALTER TABLE rebase.roles 
+            ADD COLUMN IF NOT EXISTS collection_permissions JSONB
+        `);
+    await db.execute(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(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(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(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(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;
@@ -9749,9 +10378,54 @@ class UserService {
     const [user] = await this.db.select().from(users).where(eq$3(users.email, email.toLowerCase()));
     return user || null;
   }
-  async getUserByGoogleId(googleId) {
-    const [user] = await this.db.select().from(users).where(eq$3(users.googleId, googleId));
-    return user || null;
+  async getUserByIdentity(provider, providerId) {
+    const result = await this.db.execute(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(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({
@@ -9772,6 +10446,7 @@ class UserService {
     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",
@@ -9781,42 +10456,34 @@ class UserService {
     };
     const orderColumn = columnMap[orderBy] || "created_at";
     const direction = orderDir === "asc" ? sql`ASC` : sql`DESC`;
-    let rows;
-    let total;
+    const conditions = [];
+    if (roleId) {
+      conditions.push(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(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(sql`
-                SELECT * FROM rebase.users
-                WHERE email ILIKE ${pattern} OR display_name ILIKE ${pattern}
-                ORDER BY ${sql.raw(orderColumn)} ${direction}
-                LIMIT ${limit} OFFSET ${offset}
-            `);
-      rows = dataResult.rows;
-    } else {
-      const countResult = await this.db.execute(sql`
-                SELECT count(*)::int as total FROM rebase.users
-            `);
-      total = countResult.rows[0].total;
-      const dataResult = await this.db.execute(sql`
-                SELECT * FROM rebase.users
-                ORDER BY ${sql.raw(orderColumn)} ${direction}
-                LIMIT ${limit} OFFSET ${offset}
-            `);
-      rows = dataResult.rows;
+      conditions.push(sql`(email ILIKE ${pattern} OR display_name ILIKE ${pattern})`);
     }
+    const whereClause = conditions.length > 0 ? sql`WHERE ${sql.join(conditions, sql` AND `)}` : sql``;
+    const orderByClause = roleId ? sql`ORDER BY ${sql.raw(orderColumn)} ${direction}` : sql`ORDER BY (SELECT count(*) FROM rebase.user_roles ur WHERE ur.user_id = users.id) DESC, ${sql.raw(orderColumn)} ${direction}`;
+    const countResult = await this.db.execute(sql`
+            SELECT count(*)::int as total FROM rebase.users
+            ${whereClause}
+        `);
+    const total = countResult.rows[0].total;
+    const dataResult = await this.db.execute(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,
@@ -10190,8 +10857,14 @@ class PostgresAuthRepository {
   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);
@@ -10319,16 +10992,6 @@ class HistoryService {
       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;
     }
@@ -10490,6 +11153,7 @@ function createPostgresBootstrapper(pgConfig) {
       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) => {
@@ -10556,9 +11220,6 @@ function createPostgresBootstrapper(pgConfig) {
       const internals = driverResult.internals;
       const db = internals.db;
       await ensureAuthTablesExist(db);
-      if (authConfig.google?.clientId) {
-        configureGoogleOAuth(authConfig.google.clientId);
-      }
       let emailService;
       if (authConfig.email) {
         emailService = createEmailService(authConfig.email);
@@ -10627,6 +11288,8 @@ export {
   refreshTokensRelations,
   roles,
   rolesRelations,
+  userIdentities,
+  userIdentitiesRelations,
   userRoles,
   userRolesRelations,
   users,