@firecms/core 3.0.1 → 3.1.0-canary.7d91b7c

package/src/util/callbacks.ts

@@ -1,4 +1,5 @@
 import { EntityCallbacks } from "../types";
+import { mergeDeep } from "./objects";
 
 export const mergeCallbacks = (
     baseCallbacks: EntityCallbacks = {},
@@ -55,17 +56,19 @@ export const mergeCallbacks = (
     // Handle onPreSave - returns Partial<EntityValues<M>> or Promise<Partial<EntityValues<M>>>
     if (baseCallbacks.onPreSave || pluginCallbacks.onPreSave) {
         mergedCallbacks.onPreSave = async (props) => {
-            let values = { ...props.values };
+            let values = props.values;
             if (baseCallbacks.onPreSave) {
                 const baseValues = await Promise.resolve(baseCallbacks.onPreSave(props));
-                values = { ...values, ...baseValues };
+                // Use mergeDeep to preserve class instances like EntityReference, GeoPoint
+                values = mergeDeep(values, baseValues);
             }
             if (pluginCallbacks.onPreSave) {
                 const pluginValues = await Promise.resolve(pluginCallbacks.onPreSave({
                     ...props,
                     values
                 }));
-                values = { ...values, ...pluginValues };
+                // Use mergeDeep to preserve class instances like EntityReference, GeoPoint
+                values = mergeDeep(values, pluginValues);
             }
             return values;
         };

package/src/util/collections.ts

@@ -11,10 +11,11 @@ import { isPropertyBuilder } from "./entities";
 export function sortProperties<M extends Record<string, any>>(properties: PropertiesOrBuilders<M>, propertiesOrder?: (keyof M)[]): PropertiesOrBuilders<M> {
     try {
         const propertiesKeys = Object.keys(properties);
-        const allPropertiesOrder = propertiesOrder ?? propertiesKeys;
-        return allPropertiesOrder
-            .map((key) => {
-                if (properties[key as keyof M]) {
+
+        // If no propertiesOrder, just use the original keys order
+        if (!propertiesOrder || propertiesOrder.length === 0) {
+            return propertiesKeys
+                .map((key) => {
                     const property = properties[key] as PropertyOrBuilder;
                     if (!isPropertyBuilder(property) && property?.dataType === "map" && property.properties) {
                         return ({
@@ -26,12 +27,56 @@ export function sortProperties<M extends Record<string, any>>(properties: Proper
                     } else {
                         return ({ [key]: property });
                     }
+                })
+                .reduce((a: any, b: any) => ({ ...a, ...b }), {}) as PropertiesOrBuilders<M>;
+        }
+
+        // Filter propertiesOrder to only include TOP-LEVEL property keys that exist
+        // (ignore nested keys like "data.mode" - they are for column ordering, not property filtering)
+        const validOrderKeys = (propertiesOrder as string[]).filter(key => {
+            // Only include top-level keys (no dots) that exist in properties
+            return !key.includes(".") && properties[key as keyof M];
+        });
+
+        // Track which properties we've processed
+        const processedKeys = new Set<string>(validOrderKeys);
+
+        // Build result starting with ordered properties
+        const orderedResult = validOrderKeys
+            .map((key) => {
+                const property = properties[key] as PropertyOrBuilder;
+                if (!isPropertyBuilder(property) && property?.dataType === "map" && property.properties) {
+                    return ({
+                        [key]: {
+                            ...property,
+                            properties: sortProperties(property.properties, property.propertiesOrder)
+                        }
+                    });
                 } else {
-                    return undefined;
+                    return ({ [key]: property });
                 }
             })
-            .filter((a) => a !== undefined)
             .reduce((a: any, b: any) => ({ ...a, ...b }), {}) as PropertiesOrBuilders<M>;
+
+        // Append any properties that were NOT in propertiesOrder (so they don't disappear!)
+        const missingProperties = propertiesKeys
+            .filter(key => !processedKeys.has(key))
+            .map((key) => {
+                const property = properties[key] as PropertyOrBuilder;
+                if (!isPropertyBuilder(property) && property?.dataType === "map" && property.properties) {
+                    return ({
+                        [key]: {
+                            ...property,
+                            properties: sortProperties(property.properties, property.propertiesOrder)
+                        }
+                    });
+                } else {
+                    return ({ [key]: property });
+                }
+            })
+            .reduce((a: any, b: any) => ({ ...a, ...b }), {}) as PropertiesOrBuilders<M>;
+
+        return { ...orderedResult, ...missingProperties };
     } catch (e) {
         console.error("Error sorting properties", e);
         return properties;

package/src/util/conditions.ts

@@ -0,0 +1,339 @@
+import jsonLogic from "json-logic-js";
+import {
+    AuthController,
+    ConditionContext,
+    EnumValueConfig,
+    JsonLogicRule,
+    PropertyConditions,
+    ResolvedProperty,
+    CMSType,
+    Role
+} from "../types";
+import { getIn } from "@firecms/formex";
+
+let operationsRegistered = false;
+
+/**
+ * Register custom JSON Logic operations for FireCMS.
+ * Call this once at app initialization.
+ */
+export function registerConditionOperations(): void {
+    if (operationsRegistered) return;
+
+    // Check if user has a specific role by ID
+    jsonLogic.add_operation("hasRole", function (this: ConditionContext, roleId: string) {
+        return this?.user?.roles?.includes(roleId) ?? false;
+    });
+
+    // Check if user has any of the specified roles
+    jsonLogic.add_operation("hasAnyRole", function (this: ConditionContext, roleIds: string[]) {
+        if (!this?.user?.roles || !Array.isArray(roleIds)) return false;
+        return roleIds.some(role => this.user.roles.includes(role));
+    });
+
+    // Check if a timestamp is today
+    jsonLogic.add_operation("isToday", (timestamp: number) => {
+        if (!timestamp) return false;
+        const date = new Date(timestamp);
+        const today = new Date();
+        return date.getFullYear() === today.getFullYear() &&
+            date.getMonth() === today.getMonth() &&
+            date.getDate() === today.getDate();
+    });
+
+    // Check if a timestamp is in the past
+    jsonLogic.add_operation("isPast", (timestamp: number) => {
+        if (!timestamp) return false;
+        return timestamp < Date.now();
+    });
+
+    // Check if a timestamp is in the future
+    jsonLogic.add_operation("isFuture", (timestamp: number) => {
+        if (!timestamp) return false;
+        return timestamp > Date.now();
+    });
+
+    operationsRegistered = true;
+}
+
+/**
+ * Evaluate a JSON Logic rule against the given context.
+ */
+export function evaluateCondition(rule: JsonLogicRule, context: ConditionContext): any {
+    // Ensure operations are registered
+    registerConditionOperations();
+    return jsonLogic.apply(rule, context);
+}
+
+/**
+ * Convert a value to a format suitable for JSON Logic evaluation.
+ * Specifically handles Date objects by converting them to Unix timestamps.
+ */
+function serializeValueForConditions(value: any): any {
+    if (value === null || value === undefined) {
+        return value;
+    }
+
+    // Handle Date objects
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+
+    // Handle Firestore Timestamp-like objects (have toDate or toMillis)
+    if (typeof value?.toMillis === "function") {
+        return value.toMillis();
+    }
+    if (typeof value?.toDate === "function") {
+        return value.toDate().getTime();
+    }
+
+    // Handle arrays recursively
+    if (Array.isArray(value)) {
+        return value.map(serializeValueForConditions);
+    }
+
+    // Handle plain objects recursively
+    if (typeof value === "object") {
+        const result: Record<string, any> = {};
+        for (const key of Object.keys(value)) {
+            result[key] = serializeValueForConditions(value[key]);
+        }
+        return result;
+    }
+
+    return value;
+}
+
+/**
+ * Build a ConditionContext from the current property resolution context.
+ */
+export function buildConditionContext(params: {
+    propertyKey?: string;
+    values?: Record<string, any>;
+    previousValues?: Record<string, any>;
+    path: string;
+    entityId?: string;
+    index?: number;
+    authController: AuthController;
+}): ConditionContext {
+    const {
+        propertyKey,
+        values,
+        previousValues,
+        path,
+        entityId,
+        index,
+        authController
+    } = params;
+
+    const user = authController.user;
+    const serializedValues = serializeValueForConditions(values ?? {});
+    const serializedPreviousValues = serializeValueForConditions(previousValues ?? values ?? {});
+
+    return {
+        values: serializedValues,
+        previousValues: serializedPreviousValues,
+        propertyValue: propertyKey ? getIn(serializedValues, propertyKey) : undefined,
+        path,
+        entityId,
+        isNew: !entityId,
+        index,
+        user: {
+            uid: user?.uid ?? "",
+            email: user?.email ?? null,
+            displayName: user?.displayName ?? null,
+            photoURL: user?.photoURL ?? null,
+            roles: user?.roles?.map((r: Role) => r.id) ?? []
+        },
+        now: Date.now()
+    };
+}
+
+/**
+ * Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
+ */
+export function applyPropertyConditions<T extends CMSType>(
+    property: ResolvedProperty<T>,
+    context: ConditionContext
+): ResolvedProperty<T> {
+    const { conditions } = property;
+    if (!conditions) return property;
+
+    let result = { ...property };
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // FIELD STATE CONDITIONS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    // Evaluate disabled condition
+    if (conditions.disabled) {
+        const isDisabled = evaluateCondition(conditions.disabled, context);
+        if (isDisabled) {
+            result.disabled = {
+                clearOnDisabled: conditions.clearOnDisabled ?? false,
+                disabledMessage: conditions.disabledMessage,
+                hidden: false
+            };
+        }
+    }
+
+    // Evaluate hidden condition
+    if (conditions.hidden) {
+        const isHidden = evaluateCondition(conditions.hidden, context);
+        if (isHidden) {
+            result.disabled = {
+                ...(typeof result.disabled === "object" ? result.disabled : {}),
+                hidden: true,
+                clearOnDisabled: conditions.clearOnDisabled ?? false
+            };
+        }
+    }
+
+    // Evaluate readOnly condition
+    if (conditions.readOnly) {
+        const isReadOnly = evaluateCondition(conditions.readOnly, context);
+        if (isReadOnly) {
+            result.readOnly = true;
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // VALIDATION CONDITIONS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    // Evaluate required condition
+    if (conditions.required !== undefined) {
+        const isRequired = evaluateCondition(conditions.required, context);
+        result.validation = {
+            ...result.validation,
+            required: isRequired,
+            requiredMessage: conditions.requiredMessage
+        };
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // VALUE CONDITIONS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    // Apply default value for new entities
+    if (context.isNew && conditions.defaultValue !== undefined) {
+        result.defaultValue = evaluateCondition(conditions.defaultValue, context);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ENUM CONDITIONS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    if ("enumValues" in result && result.enumValues && (conditions.enumConditions || conditions.allowedEnumValues || conditions.excludedEnumValues)) {
+        (result as any).enumValues = applyEnumConditions(
+            result.enumValues as EnumValueConfig[],
+            conditions,
+            context
+        );
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // REFERENCE CONDITIONS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    if (result.dataType === "reference") {
+        if (conditions.referencePath) {
+            (result as any).path = evaluateCondition(conditions.referencePath, context);
+        }
+        if (conditions.referenceFilter) {
+            (result as any).forceFilter = evaluateCondition(conditions.referenceFilter, context);
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // ARRAY CONDITIONS
+    // ═══════════════════════════════════════════════════════════════════════
+
+    if (result.dataType === "array") {
+        if (conditions.canAddElements !== undefined) {
+            (result as any).canAddElements = evaluateCondition(conditions.canAddElements, context);
+        }
+        if (conditions.sortable !== undefined) {
+            (result as any).sortable = evaluateCondition(conditions.sortable, context);
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Convert an object with numeric keys back to an array.
+ * Firestore stores arrays as {"0": "a", "1": "b"} to avoid nested arrays.
+ */
+function objectToArray(obj: unknown): string[] {
+    if (Array.isArray(obj)) return obj.map(String);
+    if (obj && typeof obj === "object") {
+        const keys = Object.keys(obj);
+        if (keys.length > 0 && keys.every(k => !isNaN(Number(k)))) {
+            return keys
+                .sort((a, b) => Number(a) - Number(b))
+                .map(k => (obj as Record<string, unknown>)[k])
+                .filter((v): v is string => typeof v === "string" || typeof v === "number")
+                .map(String);
+        }
+    }
+    return [];
+}
+
+/**
+ * Apply enum-specific conditions to filter and modify enum values.
+ */
+function applyEnumConditions(
+    enumValues: EnumValueConfig[],
+    conditions: PropertyConditions,
+    context: ConditionContext
+): EnumValueConfig[] {
+    let result = [...enumValues];
+
+    // Apply allowedEnumValues filter
+    if (conditions.allowedEnumValues) {
+        const allowed = evaluateCondition(conditions.allowedEnumValues, context);
+        // Handle both array format and object-with-numeric-keys format (Firestore workaround)
+        const allowedArray = objectToArray(allowed);
+        if (allowedArray.length > 0) {
+            result = result.filter(ev => allowedArray.includes(String(ev.id)));
+        }
+    }
+
+    // Apply excludedEnumValues filter
+    if (conditions.excludedEnumValues) {
+        const excluded = evaluateCondition(conditions.excludedEnumValues, context);
+        // Handle both array format and object-with-numeric-keys format
+        const excludedArray = objectToArray(excluded);
+        if (excludedArray.length > 0) {
+            result = result.filter(ev => !excludedArray.includes(String(ev.id)));
+        }
+    }
+
+    // Apply individual enum conditions
+    if (conditions.enumConditions) {
+        result = result
+            .map(ev => {
+                const evConditions = conditions.enumConditions?.[ev.id];
+                if (!evConditions) return ev;
+
+                // Check hidden condition first
+                if (evConditions.hidden && evaluateCondition(evConditions.hidden, context)) {
+                    return null; // Will be filtered out
+                }
+
+                // Check disabled condition
+                if (evConditions.disabled && evaluateCondition(evConditions.disabled, context)) {
+                    return {
+                        ...ev,
+                        disabled: true
+                    };
+                }
+
+                return ev;
+            })
+            .filter((ev): ev is EnumValueConfig => ev !== null);
+    }
+
+    return result;
+}

package/src/util/entities.ts

@@ -14,6 +14,7 @@ import {
     ResolvedProperty
 } from "../types";
 import { DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "./common";
+import { mergeDeep } from "./objects";
 
 export function isReadOnly(property: Property<any> | ResolvedProperty<any>): boolean {
     if (property.readOnly)
@@ -32,7 +33,7 @@ export function isHidden(property: Property | ResolvedProperty): boolean {
     return typeof property.disabled === "object" && Boolean(property.disabled.hidden);
 }
 
-export function isPropertyBuilder<T extends CMSType, M extends Record<string, any>>(propertyOrBuilder?: PropertyOrBuilder<T, M> | Property<T> | ResolvedProperty<T>): propertyOrBuilder is PropertyBuilder<T, M> {
+export function isPropertyBuilder<T extends CMSType = CMSType, M extends Record<string, any> = any>(propertyOrBuilder?: PropertyOrBuilder<T, M> | Property | ResolvedProperty): propertyOrBuilder is PropertyBuilder<T, M> {
     return typeof propertyOrBuilder === "function";
 }
 
@@ -84,36 +85,30 @@ export function getDefaultValueForDataType(dataType: DataType) {
  * @group Datasource
  */
 export function updateDateAutoValues<M extends Record<string, any>>({
-                                                                        inputValues,
-                                                                        properties,
-                                                                        status,
-                                                                        timestampNowValue,
-                                                                        setDateToMidnight
-                                                                    }:
-                                                                        {
-                                                                            inputValues: Partial<EntityValues<M>>,
-                                                                            properties: ResolvedProperties<M>,
-                                                                            status: EntityStatus,
-                                                                            timestampNowValue: any,
-                                                                            setDateToMidnight: (input?: any) => any | undefined
-                                                                        }): EntityValues<M> {
+    inputValues,
+    properties,
+    status,
+    timestampNowValue
+}:
+    {
+        inputValues: Partial<EntityValues<M>>,
+        properties: ResolvedProperties<M>,
+        status: EntityStatus,
+        timestampNowValue: any
+    }): EntityValues<M> {
     return traverseValuesProperties(
         inputValues,
         properties,
         (inputValue, property) => {
             if (property.dataType === "date") {
-                let resultDate;
                 if (status === "existing" && property.autoValue === "on_update") {
-                    resultDate = timestampNowValue;
+                    return timestampNowValue;
                 } else if ((status === "new" || status === "copy") &&
                     (property.autoValue === "on_update" || property.autoValue === "on_create")) {
-                    resultDate = timestampNowValue;
+                    return timestampNowValue;
                 } else {
-                    resultDate = inputValue;
+                    return inputValue;
                 }
-                if (property.mode === "date")
-                    resultDate = setDateToMidnight(resultDate);
-                return resultDate;
             } else {
                 return inputValue;
             }
@@ -128,10 +123,10 @@ export function updateDateAutoValues<M extends Record<string, any>>({
  * @group Datasource
  */
 export function sanitizeData<M extends Record<string, any>>
-(
-    values: EntityValues<M>,
-    properties: ResolvedProperties<M>
-) {
+    (
+        values: EntityValues<M>,
+        properties: ResolvedProperties<M>
+    ) {
     const result: any = values;
     Object.entries(properties)
         .forEach(([key, property]) => {
@@ -150,23 +145,27 @@ export function traverseValuesProperties<M extends Record<string, any>>(
     properties: ResolvedProperties<M>,
     operation: (value: any, property: Property) => any
 ): EntityValues<M> | undefined {
+    // Handle null/undefined inputValues - use empty object as base for mergeDeep
+    const safeInputValues = inputValues ?? {};
+
     const updatedValues = Object.entries(properties)
         .map(([key, property]) => {
-            const inputValue = inputValues && (inputValues)[key];
+            const inputValue = safeInputValues && (safeInputValues)[key];
             const updatedValue = traverseValueProperty(inputValue, property as Property, operation);
             if (updatedValue === null) return null;
             if (updatedValue === undefined) return undefined;
             return ({ [key]: updatedValue });
         })
         .reduce((a, b) => ({ ...a, ...b }), {}) as EntityValues<M>;
-    const result = { ...inputValues, ...updatedValues };
-    if (Object.keys(result).length === 0) return undefined;
+    // Use mergeDeep to preserve class instances like EntityReference, GeoPoint
+    const result = mergeDeep(safeInputValues, updatedValues);
+    if (!result || Object.keys(result).length === 0) return undefined;
     return result;
 }
 
 export function traverseValueProperty(inputValue: any,
-                                      property: Property,
-                                      operation: (value: any, property: Property) => any): any {
+    property: Property,
+    operation: (value: any, property: Property) => any): any {
 
     let value;
     if (property.dataType === "map" && property.properties) {

package/src/util/entity_cache.ts

@@ -87,8 +87,9 @@ export function saveEntityToCache(path: string, data: object): void {
     if (isLocalStorageAvailable) {
         try {
             const key = LOCAL_STORAGE_PREFIX + path;
+
             const entityString = JSON.stringify(data, customReplacer);
-            console.log("Saving entity to localStorage:", {
+            console.debug("Saving entity to localStorage:", {
                 key,
                 entityString
             });

package/src/util/index.ts

@@ -16,7 +16,7 @@ export * from "./icon_list";
 export * from "./icon_synonyms";
 export * from "./icons";
 export * from "./plurals";
-export * from "./references";
+export * from "./previews";
 export * from "./flatten_object";
 export * from "./make_properties_editable";
 export * from "./join_collections";
@@ -24,3 +24,4 @@ export * from "./builders";
 export * from "./useTraceUpdate";
 export * from "./storage";
 export * from "./callbacks";
+export * from "./conditions";

package/src/util/join_collections.ts

@@ -11,8 +11,8 @@ import { sortProperties } from "./collections";
 import { isPropertyBuilder } from "./entities";
 
 function applyModifyFunction(modifyCollection: ((props: ModifyCollectionProps) => (EntityCollection | void)) | undefined,
-                             collection: EntityCollection,
-                             parentPaths: string[]) {
+    collection: EntityCollection,
+    parentPaths: string[]) {
     if (modifyCollection) {
         const modified = modifyCollection({
             collection,
@@ -34,9 +34,9 @@ function applyModifyFunction(modifyCollection: ((props: ModifyCollectionProps) =
  *
  */
 export function joinCollectionLists(targetCollections: EntityCollection[],
-                                    sourceCollections: EntityCollection[] | undefined,
-                                    parentPaths: string[] = [],
-                                    modifyCollection?: (props: ModifyCollectionProps) => EntityCollection | void): EntityCollection[] {
+    sourceCollections: EntityCollection[] | undefined,
+    parentPaths: string[] = [],
+    modifyCollection?: (props: ModifyCollectionProps) => EntityCollection | void): EntityCollection[] {
 
     // merge collections that are in both lists
     const updatedCollections = (sourceCollections ?? [])
@@ -73,9 +73,9 @@ export function joinCollectionLists(targetCollections: EntityCollection[],
  *
  */
 export function mergeCollection(target: EntityCollection,
-                                source: EntityCollection,
-                                parentPaths: string[] = [],
-                                modifyCollection?: (props: ModifyCollectionProps) => EntityCollection | void
+    source: EntityCollection,
+    parentPaths: string[] = [],
+    modifyCollection?: (props: ModifyCollectionProps) => EntityCollection | void
 ): EntityCollection {
 
     const subcollectionsMerged = joinCollectionLists(
@@ -125,6 +125,8 @@ export function mergeCollection(target: EntityCollection,
 }
 
 function mergePropertyOrBuilder(target: PropertyOrBuilder, source: PropertyOrBuilder): PropertyOrBuilder {
+    if (!source) return target;
+    if (!target) return source;
     if (isPropertyBuilder(source)) {
         return source;
     } else if (isPropertyBuilder(target)) {