@rebasepro/common 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/README.md

@@ -69,9 +69,9 @@ Rebase has been meticulously crafted to make it incredibly easy for developers
 to build a CMS/admin tool while offering an excellent data editing experience
 and a user-friendly interface for marketers and content managers.
 
-### 🏓 Exceptional Spreadsheet View
+### 🏓 Exceptional Table View
 
-We've developed a highly efficient windowed **spreadsheet view** for
+We've developed a highly efficient windowed **table view** for
 collections, allowing inline editing for most common fields, as well as popup
 views for other cases and your custom field implementations.
 

package/dist/collections/CollectionRegistry.d.ts

@@ -3,9 +3,11 @@ export declare class CollectionRegistry {
     private collectionsByTableName;
     private collectionsBySlug;
     private rootCollections;
+    private cachedCollectionsList;
     private rawCollectionsByTableName;
     private rawCollectionsBySlug;
     private rawRootCollections;
+    private cachedRawCollectionsList;
     private lastRawInputSnapshot;
     constructor(collections?: EntityCollection[]);
     reset(): void;
@@ -21,6 +23,12 @@ export declare class CollectionRegistry {
     register(collection: EntityCollection, rawCollection?: EntityCollection): void;
     private _registerRecursively;
     normalizeCollection(collection: EntityCollection): EntityCollection;
+    /**
+     * 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.
+     */
+    private extractRelationsFromProperties;
     private normalizeProperties;
     private normalizeProperty;
     get(path: string): EntityCollection | undefined;

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { EntityReference, EntityRelation, isFirebaseCollection, isPostgresCollection } from "@rebasepro/types";
+import { EntityReference, EntityRelation, getDataSourceCapabilities } from "@rebasepro/types";
 import { mergeDeep, getIn as getIn$1, isDefaultFieldConfigId, randomString, toSnakeCase, generateForeignKeyName, removeFunctions } from "@rebasepro/utils";
 import jsonLogic from "json-logic-js";
 import { deepEqual } from "fast-equals";
@@ -108,7 +108,7 @@ function normalizeToEntityRelation(value) {
   if (value instanceof EntityRelation) return value;
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const obj = value;
-  const isRelationLike = obj.__type === "relation" || typeof obj.isEntityRelation === "function" && obj.isEntityRelation();
+  const isRelationLike = obj.__type === "relation" || obj.__type === "reference" || typeof obj.isEntityRelation === "function" && obj.isEntityRelation() || typeof obj.isEntityReference === "function" && obj.isEntityReference();
   if (!isRelationLike) return null;
   return new EntityRelation(obj.id, obj.path, obj.data);
 }
@@ -166,6 +166,21 @@ function traverseValueProperty(inputValue, property, operation) {
   }
   return value;
 }
+function createRelationRef(id, path) {
+  return {
+    id,
+    path,
+    __type: "relation"
+  };
+}
+function createRelationRefWithData(id, path, data) {
+  return {
+    id,
+    path,
+    __type: "relation",
+    data
+  };
+}
 function sortProperties(properties, propertiesOrder) {
   try {
     const propertiesKeys = Object.keys(properties);
@@ -307,22 +322,24 @@ function resolveProperty(props) {
   let resultProperty;
   if (isPropertyBuilder(property)) {
     const path = rest.path;
-    if (!path) throw Error("Trying to resolve a property builder without specifying the entity path");
-    const usedPropertyValue = rest.propertyKey ? getIn$1(rest.values, rest.propertyKey) : void 0;
-    const dynamicProps = property.dynamicProps?.({
-      ...rest,
-      path,
-      propertyValue: usedPropertyValue,
-      values: rest.values ?? {},
-      previousValues: rest.previousValues ?? rest.values ?? {}
-    });
-    resultProperty = mergeDeep(property, dynamicProps ?? {});
+    if (!path) {
+      resultProperty = property;
+    } else {
+      const usedPropertyValue = rest.propertyKey ? getIn$1(rest.values, rest.propertyKey) : void 0;
+      const dynamicProps = property.dynamicProps?.({
+        ...rest,
+        path,
+        propertyValue: usedPropertyValue,
+        values: rest.values ?? {},
+        previousValues: rest.previousValues ?? rest.values ?? {}
+      });
+      resultProperty = mergeDeep(property, dynamicProps ?? {});
+    }
   } else {
     resultProperty = property;
   }
-  if (resultProperty.dynamicProps) {
+  if (resultProperty?.dynamicProps && rest.path) {
     const path = rest.path;
-    if (!path) throw Error("Trying to resolve dynamicProps without specifying the entity path");
     const usedPropertyValue = rest.propertyKey ? getIn$1(rest.values, rest.propertyKey) : void 0;
     const dynamicPropsResult = resultProperty.dynamicProps({
       ...rest,
@@ -383,10 +400,14 @@ function resolveProperty(props) {
   }
   return resolvedProperty;
 }
-function resolveRelationProperty(property, relations) {
-  const relation = relations.find((rel) => rel.relationName === property.relationName);
+function resolveRelationProperty(property, relations, propertyKey) {
+  if (property.relation) {
+    return property;
+  }
+  const name = property.relationName || propertyKey;
+  const relation = name ? relations.find((rel) => rel.relationName === name) : void 0;
   if (!relation) {
-    throw Error(`Relation ${property.relationName} not found`);
+    throw Error(`Relation ${name ?? "(unnamed)"} not found`);
   }
   return {
     ...property,
@@ -518,15 +539,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 [];
 }
@@ -594,8 +635,8 @@ function evaluateAST(sqlString, auth, entity) {
     const userRoles = auth.user?.roles || [];
     return requiredRoles.every((r) => userRoles.includes(r));
   }
-  const pattern1 = new RegExp(`^\\{?([a-zA-Z0-9_]+)\\}?\\s*=\\s*(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))`);
-  const pattern2 = new RegExp(`^(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))\\s*=\\s*\\{?([a-zA-Z0-9_]+)\\}?`);
+  const pattern1 = new RegExp("^\\{?([a-zA-Z0-9_]+)\\}?\\s*=\\s*(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))");
+  const pattern2 = new RegExp("^(?:current_setting\\s*\\(\\s*'app\\.user_id'\\s*\\)|auth\\.uid\\(\\))\\s*=\\s*\\{?([a-zA-Z0-9_]+)\\}?");
   const match1 = cleanedSQL.match(pattern1);
   if (match1 && match1[1]) {
     return entity.values[match1[1]] === auth.user?.uid;
@@ -628,7 +669,7 @@ function evaluateRule(rule, auth, entity) {
   return true;
 }
 function checkOperation(collection, authController, entity, targetOperation) {
-  const securityRules = isPostgresCollection(collection) ? collection.securityRules : void 0;
+  const securityRules = getDataSourceCapabilities(collection.driver).supportsRLS ? collection.securityRules : void 0;
   if (!securityRules || securityRules.length === 0) {
     return true;
   }
@@ -1157,7 +1198,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 {
@@ -1183,7 +1224,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;
@@ -1217,14 +1258,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 relations = {};
-  if (collection.relations) {
-    collection.relations.forEach((relation) => {
+  const registeredRelationNames = /* @__PURE__ */ new Set();
+  if (relCollection.relations) {
+    relCollection.relations.forEach((relation) => {
       const normalizedRelation = sanitizeRelation(relation, collection);
       const relationKey = normalizedRelation.relationName;
       if (relationKey) {
         relations[relationKey] = normalizedRelation;
+        registeredRelationNames.add(relationKey);
       }
     });
   }
@@ -1236,15 +1284,17 @@ function resolveCollectionRelations(collection) {
         sourceCollection: collection
       });
       if (relation) {
-        if (!relations[propKey]) {
-          if (!relation.relationName) {
-            relation.relationName = propKey;
-          }
-          relations[propKey] = sanitizeRelation(relation, collection);
+        if (relations[propKey]) return;
+        if (!relation.relationName) {
+          relation.relationName = propKey;
         }
+        const normalizedRelation = sanitizeRelation(relation, collection);
+        relations[propKey] = normalizedRelation;
+        registeredRelationNames.add(normalizedRelation.relationName ?? propKey);
       }
     });
   }
+  _resolvedRelationsCache.set(collection, relations);
   return relations;
 }
 function resolvePropertyRelation({
@@ -1253,7 +1303,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;
@@ -1261,7 +1328,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);
@@ -1277,6 +1344,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;
+}
 function getIn(obj, path) {
   if (!obj || !path) return void 0;
   return path.split(".").reduce((acc, part) => acc && acc[part], obj);
@@ -1372,7 +1447,7 @@ function applyPropertyConditions(property, context) {
     conditions
   } = property;
   if (!conditions) return property;
-  let result = {
+  const result = {
     ...property
   };
   if (conditions.disabled) {
@@ -1482,10 +1557,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;
@@ -1498,9 +1575,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.
@@ -1533,12 +1612,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(rawSubcollections[subIndex]));
+      if (subcollections && subcollections.length > 0) {
+        subcollections.forEach((subCollection) => {
+          if (!subCollection) return;
+          this._registerRecursively(this.normalizeCollection({
+            ...subCollection
+          }), cloneDeep(subCollection));
         });
       }
     });
@@ -1564,41 +1645,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(rawSubcollections[index]));
+    const subcollections = getSubcollections(normalizedCollection);
+    if (subcollections && subcollections.length > 0) {
+      subcollections.forEach((subCollection) => {
+        if (!subCollection) return;
+        this._registerRecursively(this.normalizeCollection({
+          ...subCollection
+        }), cloneDeep(subCollection));
       });
     }
   }
   normalizeCollection(collection) {
-    const relations = isPostgresCollection(collection) ? collection.relations ?? [] : [];
-    const properties = this.normalizeProperties(collection.properties, relations);
-    collection.properties = properties;
-    if (!collection.childCollections) {
-      if (isFirebaseCollection(collection) && collection.subcollections) {
-        collection.childCollections = collection.subcollections;
-      } else if (isPostgresCollection(collection) && collection.relations) {
-        const manyRelations = collection.relations.filter((r) => r.cardinality === "many");
+    const result = {
+      ...collection
+    };
+    const extractedRelations = this.extractRelationsFromProperties(result.properties);
+    const relResult = result;
+    const manualRelations = getDataSourceCapabilities(result.driver).supportsRelations ? relResult.relations ?? [] : [];
+    const mergedRelationsRaw = [...extractedRelations];
+    for (const manual of manualRelations) {
+      const name = manual.relationName;
+      if (!name || !mergedRelationsRaw.find((r) => r.relationName === name)) {
+        mergedRelationsRaw.push(manual);
+      }
+    }
+    let mergedRelations = mergedRelationsRaw;
+    if (getDataSourceCapabilities(result.driver).supportsRelations) {
+      mergedRelations = mergedRelationsRaw.map((r) => {
+        try {
+          return sanitizeRelation(r, result);
+        } catch {
+          return r;
+        }
+      });
+      relResult.relations = mergedRelations;
+    }
+    const properties = this.normalizeProperties(result.properties, mergedRelations);
+    result.properties = properties;
+    if (!result.childCollections) {
+      if (getDataSourceCapabilities(result.driver).supportsSubcollections && result.subcollections) {
+        result.childCollections = result.subcollections;
+      } else if (getDataSourceCapabilities(result.driver).supportsRelations && relResult.relations) {
+        const manyRelations = relResult.relations.filter((r) => r.cardinality === "many");
         if (manyRelations.length > 0) {
-          collection.childCollections = () => manyRelations.map((r) => {
+          result.childCollections = () => manyRelations.map((r) => {
             const target = r.target();
             return r.overrides ? mergeDeep(target, r.overrides) : target;
           });
         }
       }
     }
-    return collection;
+    return result;
+  }
+  /**
+   * Extract Relation[] from properties that have inline relation config (i.e. `target` is set).
+   * This allows developers to define relations directly on properties without a separate
+   * `relations[]` entry on the collection.
+   */
+  extractRelationsFromProperties(properties) {
+    const relations = [];
+    for (const [key, property] of Object.entries(properties)) {
+      if (property.type === "relation") {
+        const relProp = property;
+        const target = relProp.target ?? relProp.relation?.target;
+        if (target) {
+          const relationName = relProp.relationName ?? relProp.relation?.relationName ?? key;
+          relations.push({
+            relationName,
+            target,
+            cardinality: relProp.cardinality ?? relProp.relation?.cardinality ?? "one",
+            direction: relProp.direction ?? relProp.relation?.direction ?? "owning",
+            inverseRelationName: relProp.inverseRelationName ?? relProp.relation?.inverseRelationName,
+            localKey: relProp.localKey ?? relProp.relation?.localKey,
+            foreignKeyOnTarget: relProp.foreignKeyOnTarget ?? relProp.relation?.foreignKeyOnTarget,
+            through: relProp.through ?? relProp.relation?.through,
+            joinPath: relProp.joinPath ?? relProp.relation?.joinPath,
+            onUpdate: relProp.onUpdate ?? relProp.relation?.onUpdate,
+            onDelete: relProp.onDelete ?? relProp.relation?.onDelete,
+            overrides: relProp.overrides ?? relProp.relation?.overrides
+          });
+        }
+      } else if (property.type === "map" && property.properties) {
+        relations.push(...this.extractRelationsFromProperties(property.properties));
+      }
+    }
+    return relations;
   }
   normalizeProperties(properties, relations) {
     const newProperties = {};
     for (const key in properties) {
-      newProperties[key] = this.normalizeProperty(properties[key], relations);
+      newProperties[key] = this.normalizeProperty(key, properties[key], relations);
     }
     return newProperties;
   }
-  normalizeProperty(property, relations) {
+  normalizeProperty(key, property, relations) {
     const newProperty = {
       ...property
     };
@@ -1608,9 +1748,9 @@ class CollectionRegistry {
       const arrayProp = newProperty;
       if (arrayProp.of) {
         if (Array.isArray(arrayProp.of)) {
-          arrayProp.of = arrayProp.of.map((p) => this.normalizeProperty(p, relations));
+          arrayProp.of = arrayProp.of.map((p, i) => this.normalizeProperty(`${key}[${i}]`, p, relations));
         } else {
-          arrayProp.of = this.normalizeProperty(arrayProp.of, relations);
+          arrayProp.of = this.normalizeProperty(`${key}.of`, arrayProp.of, relations);
         }
       } else if (arrayProp.oneOf && arrayProp.oneOf.properties) {
         arrayProp.oneOf.properties = this.normalizeProperties(arrayProp.oneOf.properties, relations);
@@ -1622,11 +1762,12 @@ class CollectionRegistry {
       }
     } else if (newProperty.type === "relation") {
       const relationProperty = newProperty;
-      const relation = relations.find((r) => r.relationName === relationProperty.relationName);
+      const name = relationProperty.relationName || key;
+      const relation = relations.find((r) => r.relationName === name);
       if (relation) {
         relationProperty.relation = relation;
       } else {
-        console.warn(`Could not find relation for property with relationName: ${relationProperty.relationName}`);
+        console.warn(`Could not find relation for property '${key}' with relationName: ${name}`);
       }
     }
     return newProperty;
@@ -1634,6 +1775,11 @@ class CollectionRegistry {
   get(path) {
     const bySlug = this.collectionsBySlug.get(path);
     if (bySlug) return bySlug;
+    if (path.includes("-")) {
+      const normalized = path.replace(/-/g, "_");
+      const byNormalized = this.collectionsBySlug.get(normalized);
+      if (byNormalized) return byNormalized;
+    }
     return this.collectionsByTableName.get(path);
   }
   /**
@@ -1643,6 +1789,11 @@ class CollectionRegistry {
   getRaw(path) {
     const bySlug = this.rawCollectionsBySlug.get(path);
     if (bySlug) return bySlug;
+    if (path.includes("-")) {
+      const normalized = path.replace(/-/g, "_");
+      const byNormalized = this.rawCollectionsBySlug.get(normalized);
+      if (byNormalized) return byNormalized;
+    }
     return this.rawCollectionsByTableName.get(path);
   }
   /**
@@ -1664,11 +1815,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}'`);
       }
@@ -1678,10 +1829,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
@@ -1737,24 +1894,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 value === "string" && !isNaN(Number(value)) && value.trim() !== "") {
-      value = Number(value);
+    if (typeof rawValue === "number") {
+      filter[field] = ["==", rawValue];
+      continue;
     }
-    const mappedOp = operatorMap[op];
-    if (mappedOp) {
-      filter[field] = [mappedOp, value];
+    if (Array.isArray(rawValue) && rawValue.length === 2) {
+      const [rawOp, val] = rawValue;
+      const mappedOp = operatorMap[rawOp] ?? "==";
+      filter[field] = [mappedOp, val];
+      continue;
+    }
+    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;
@@ -1773,7 +1968,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],
@@ -1835,7 +2030,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],
@@ -1882,7 +2077,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);
     }
   });
 }
@@ -1908,8 +2104,11 @@ export {
   canDeleteEntity,
   canEditEntity,
   canReadCollection,
+  createRelationRef,
+  createRelationRefWithData,
   enumToObjectEntries,
   evaluateCondition,
+  findRelation,
   fullPathToCollectionSegments,
   getArrayResolvedProperties,
   getCollectionBySlugWithin,