@rebasepro/common 0.0.1-canary.eae7889 → 0.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/common",
   "type": "module",
-  "version": "0.0.1-canary.eae7889",
+  "version": "0.1.0",
   "description": "Awesome Firebase/Firestore-based headless open-source CMS",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -39,10 +39,10 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "fast-equals": "5.3.0",
+    "fast-equals": "6.0.0",
     "json-logic-js": "^2.0.5",
-    "@rebasepro/utils": "0.0.1-canary.eae7889",
-    "@rebasepro/types": "0.0.1-canary.eae7889"
+    "@rebasepro/types": "0.1.0",
+    "@rebasepro/utils": "0.1.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
@@ -62,7 +62,6 @@
     "jest": "^29.7.0",
     "npm-run-all": "^4.1.5",
     "ts-jest": "^29.3.1",
-    "ts-node": "^10.9.2",
     "tsd": "^0.31.2",
     "typescript": "^5.8.3",
     "vite": "^5.4.17"

package/src/collections/CollectionRegistry.ts

@@ -165,7 +165,7 @@ export class CollectionRegistry {
 
         // 2. Merge with manual relations[] (manual entries win on name conflict)
         const relResult = result as CollectionWithRelations;
-        const manualRelations = getDataSourceCapabilities(result.driver).supportsRelations ? (relResult.relations ?? []) : [];
+        const manualRelations = getDataSourceCapabilities(result.driver).supportsRelations ? ((relResult as any).relations ?? []) : [];
         const mergedRelationsRaw = [...extractedRelations];
         for (const manual of manualRelations) {
             const name = manual.relationName;
@@ -192,7 +192,7 @@ export class CollectionRegistry {
             });
 
             // 3. Set the merged relations on the result copy
-            relResult.relations = mergedRelations;
+            (relResult as any).relations = mergedRelations;
         }
 
         // 4. Normalize properties (which stamps relation on each property)
@@ -203,8 +203,8 @@ export class CollectionRegistry {
         if (!result.childCollections) {
             if (getDataSourceCapabilities(result.driver).supportsSubcollections && (result as CollectionWithSubcollections).subcollections) {
                 result.childCollections = (result as CollectionWithSubcollections).subcollections;
-            } else if (getDataSourceCapabilities(result.driver).supportsRelations && relResult.relations) {
-                const manyRelations = relResult.relations.filter((r: Relation) => r.cardinality === "many");
+            } else if (getDataSourceCapabilities(result.driver).supportsRelations && (relResult as any).relations) {
+                const manyRelations = (relResult as any).relations.filter((r: Relation) => r.cardinality === "many");
                 if (manyRelations.length > 0) {
                     result.childCollections = () => manyRelations.map((r: Relation) => {
                         const target = r.target();
@@ -375,7 +375,10 @@ export class CollectionRegistry {
             }
 
             // Move to the target collection
-            currentCollection = relation.target();
+            const target = relation.target();
+            const targetRelationKey = relation.relationName || target.slug;
+            const targetSlug = relation.overrides?.slug ?? targetRelationKey;
+            currentCollection = this.get(targetSlug) || this.normalizeCollection(target);
 
             // If there are more segments, continue navigation
             if (i + 1 < pathSegments.length) {
@@ -447,7 +450,7 @@ export class CollectionRegistry {
                 if (!subcollection) {
                     throw new Error(`Subcollection '${subcollectionSlug}' not found in ${currentCollection.slug}`);
                 }
-                currentCollection = subcollection;
+                currentCollection = this.get(subcollection.slug) || this.normalizeCollection(subcollection);
                 collections.push(currentCollection);
             }
         }
@@ -482,8 +485,8 @@ function areCollectionsEqual(a: EntityCollection, b: EntityCollection) {
     // Remove subcollections/relations from comparison objects (already handled above)
     delete restA.subcollections;
     delete restB.subcollections;
-    delete restA.relations;
-    delete restB.relations;
+    delete (restA as any).relations;
+    delete (restB as any).relations;
     if (!areCollectionListsEqual(subcollectionsA, subcollectionsB)) {
         return false;
     }

package/src/util/conditions.ts

@@ -178,7 +178,8 @@ export function applyPropertyConditions(
     if (conditions.disabled) {
         const isDisabled = evaluateCondition(conditions.disabled, context);
         if (isDisabled) {
-            result.disabled = {
+            result.ui = result.ui || {};
+            result.ui.disabled = {
                 clearOnDisabled: conditions.clearOnDisabled ?? false,
                 disabledMessage: conditions.disabledMessage,
                 hidden: false
@@ -190,8 +191,9 @@ export function applyPropertyConditions(
     if (conditions.hidden) {
         const isHidden = evaluateCondition(conditions.hidden, context);
         if (isHidden) {
-            result.disabled = {
-                ...(typeof result.disabled === "object" ? result.disabled : {}),
+            result.ui = result.ui || {};
+            result.ui.disabled = {
+                ...(typeof result.ui?.disabled === "object" ? result.ui.disabled : {}),
                 hidden: true,
                 clearOnDisabled: conditions.clearOnDisabled ?? false
             };
@@ -202,7 +204,8 @@ export function applyPropertyConditions(
     if (conditions.readOnly) {
         const isReadOnly = evaluateCondition(conditions.readOnly, context);
         if (isReadOnly) {
-            result.readOnly = true;
+            result.ui = result.ui || {};
+            result.ui.readOnly = true;
         }
     }
 
@@ -250,7 +253,7 @@ export function applyPropertyConditions(
             (result as ReferenceProperty).path = evaluateCondition(conditions.referencePath, context) as string;
         }
         if (conditions.referenceFilter) {
-            (result as ReferenceProperty).forceFilter = evaluateCondition(conditions.referenceFilter, context) as ReferenceProperty["forceFilter"];
+            (result as ReferenceProperty).fixedFilter = evaluateCondition(conditions.referenceFilter, context) as ReferenceProperty["fixedFilter"];
         }
     }
 

package/src/util/entities.ts

@@ -12,20 +12,20 @@ import { DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "./common";
 import { mergeDeep } from "@rebasepro/utils";
 
 export function isReadOnly(property: Property): boolean {
-    if (property.readOnly)
+    if (property.ui?.readOnly)
         return true;
     if (property.type === "date") {
         if (property.autoValue)
             return true;
     }
     if (property.type === "reference") {
-        return !property.path && !("Field" in property && property.Field);
+        return !property.path && !("Field" in (property.ui || {}) && property.ui?.Field);
     }
     return false;
 }
 
 export function isHidden(property: Property): boolean {
-    return typeof property.disabled === "object" && Boolean(property.disabled.hidden);
+    return typeof property.ui?.disabled === "object" && Boolean(property.ui?.disabled.hidden);
 }
 
 export function isPropertyBuilder(property?: Property) {

package/src/util/references.ts

@@ -19,7 +19,7 @@ export function getEntityImagePreviewPropertyKey<M extends Record<string, unknow
     // also check for URL properties with image preview type
     for (const key in collection.properties) {
         const property = collection.properties[key];
-        if (property.type === "string" && property.url === "image") {
+        if (property.type === "string" && property.ui?.url === "image") {
             return key;
         }
     }

package/src/util/relations.ts

@@ -41,7 +41,7 @@ export function sanitizeRelation(relation: Partial<Relation>, sourceCollection:
 
                 try {
                     // Look for an owning relation on the target that points back to this collection
-                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? ((targetCollection as CollectionWithRelations).relations || []) : [];
+                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? (((targetCollection as any).relations) || []) : [];
                     for (const targetRel of targetRelations) {
                         if (targetRel.direction === "owning" &&
                             targetRel.cardinality === "one" &&
@@ -85,7 +85,7 @@ export function sanitizeRelation(relation: Partial<Relation>, sourceCollection:
                     // Note: we intentionally do NOT require `through` here because the raw (unsanitized)
                     // relations won't have `through` populated yet — sanitizeRelation fills it in later.
                     // `cardinality: "many" + direction: "owning"` is sufficient to identify owning M2M.
-                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? ((targetCollection as CollectionWithRelations).relations || []) : [];
+                    const targetRelations = getDataSourceCapabilities(targetCollection.driver).supportsRelations ? (((targetCollection as any).relations) || []) : [];
                     for (const targetRel of targetRelations) {
                         if (targetRel.cardinality === "many" &&
                             (targetRel.direction === "owning" || !targetRel.direction) &&
@@ -152,8 +152,8 @@ export function resolveCollectionRelations(
 
     // 1. Process explicit relations from the `relations` field.
     //    Each relation is stored once under its canonical relationName key.
-    if (relCollection.relations) {
-        relCollection.relations.forEach((relation: Relation) => {
+    if ((relCollection as any).relations) {
+        (relCollection as any).relations.forEach((relation: Relation) => {
             const normalizedRelation = sanitizeRelation(relation, collection);
             const relationKey = normalizedRelation.relationName;
             if (relationKey) {
@@ -232,7 +232,7 @@ export function resolvePropertyRelation({
     }
 
     // 2. Fall back to lookup from collection.relations[] (backward compat)
-    const relation = ((sourceCollection as CollectionWithRelations).relations ?? []).find((rel: Relation) => rel.relationName === relProp.relationName)
+    const relation = (((sourceCollection as any).relations) ?? []).find((rel: Relation) => rel.relationName === relProp.relationName)
     if (!relation) {
         console.warn(`Unrecognized relation format for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
         return undefined;

package/src/util/resolutions.ts

@@ -280,7 +280,7 @@ export function resolveArrayProperties<M>({
             }).filter(e => Boolean(e)) as Property[]
             : [];
         return resolvedProperties;
-    } else if (!("Field" in property && property.Field)) {
+    } else if (!("Field" in (property.ui || {}) && property.ui?.Field)) {
         throw Error(`The array property (${propertyKey}) needs to declare an 'of' or a 'oneOf' property, or provide a custom \`Field\` component`);
     } else {
         return [];
@@ -350,8 +350,8 @@ export function getSubcollections<M extends Record<string, unknown> = Record<str
         return (collection as CollectionWithSubcollections).subcollections!() ?? [];
     }
 
-    if (getDataSourceCapabilities(collection.driver).supportsRelations && (collection as CollectionWithRelations).relations) {
-        const manyRelations = (collection as CollectionWithRelations).relations!.filter((r: Relation) => r.cardinality === "many");
+    if (getDataSourceCapabilities(collection.driver).supportsRelations && ((collection as any).relations)) {
+        const manyRelations = ((collection as any).relations)!.filter((r: Relation) => r.cardinality === "many");
         return manyRelations.map((r: Relation) => {
             const target = r.target();
             if (!target) return undefined;
@@ -376,7 +376,7 @@ export function getSubcollections<M extends Record<string, unknown> = Record<str
 
             const targetWithOverrides = { ...target, ...baseOverrides };
             return (r.overrides ? mergeDeep(targetWithOverrides, r.overrides) : targetWithOverrides) as EntityCollection<Record<string, unknown>>;
-        }).filter((c): c is EntityCollection<Record<string, unknown>> => Boolean(c));
+        }).filter((c: any): c is EntityCollection<Record<string, unknown>> => Boolean(c));
     }
 
     return [];