@firecms/core 3.0.0-beta.12 → 3.0.0-beta.14

package/src/util/navigation_utils.ts

@@ -32,29 +32,90 @@ export function getLastSegment(path: string) {
 }
 
 export function resolveCollectionPathIds(path: string, allCollections: EntityCollection[]): string {
-
-    const cleanPath = removeInitialAndTrailingSlashes(path);
-    const subpaths = cleanPath.split("/");
-    if (subpaths.length % 2 === 0) {
-        throw Error(`resolveCollectionPathAliases: Collection paths must have an odd number of segments: ${path}`);
+    let remainingPath = removeInitialAndTrailingSlashes(path);
+    if (!remainingPath) {
+        return "";
     }
 
-    const aliasedCollection = allCollections.find((col) => col.id === subpaths[0]);
-    let resolvedAliased;
-    if (aliasedCollection) {
-        resolvedAliased = aliasedCollection.path;
-    }
+    let currentCollections: EntityCollection[] | undefined = allCollections;
+    const resolvedPathParts: string[] = [];
 
-    if (subpaths.length > 1) {
-        const segmentCollection = getCollectionByPathOrId(resolvedAliased ?? subpaths[0], allCollections);
-        if (!segmentCollection?.subcollections) {
-            return cleanPath;
+    while (remainingPath.length > 0) {
+        if (!currentCollections || currentCollections.length === 0) {
+            // We have remaining path segments but no more collections to match against
+            console.warn(`resolveCollectionPathIds: Path structure implies subcollections, but none found before segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
+            resolvedPathParts.push(remainingPath);
+            remainingPath = ""; // Stop processing
+            break;
+        }
+
+        let foundMatch = false;
+        // Sort potential matches by length descending to prioritize longer matches (e.g., "a/b" over "a")
+        const potentialMatches: { col: EntityCollection; match: string; }[] = currentCollections
+            .flatMap(col => [{
+                col,
+                match: col.path
+            }, {
+                col,
+                match: col.id
+            }])
+            .filter(p => p.match && remainingPath.startsWith(p.match))
+            .sort((a, b) => b.match.length - a.match.length);
+
+        if (potentialMatches.length > 0) {
+            const {
+                col: foundCollection,
+                match: matchString
+            } = potentialMatches[0];
+
+            resolvedPathParts.push(foundCollection.path); // Use the defined path
+            remainingPath = removeInitialSlash(remainingPath.substring(matchString.length));
+
+            // Check if we are at the end of the path
+            if (remainingPath.length === 0) {
+                foundMatch = true;
+                break; // Path ends with a collection segment
+            }
+
+            // The next segment must be an entity ID
+            const idSeparatorIndex = remainingPath.indexOf("/");
+            let entityId: string;
+            if (idSeparatorIndex > -1) {
+                entityId = remainingPath.substring(0, idSeparatorIndex);
+                remainingPath = remainingPath.substring(idSeparatorIndex + 1);
+            } else {
+                // This should not happen if the original path is valid (odd segments)
+                // but handle it defensively: assume the rest is the ID
+                entityId = remainingPath;
+                remainingPath = "";
+                console.warn(`resolveCollectionPathIds: Path seems to end with an entity ID "${entityId}" instead of a collection segment in original path "${path}". This might indicate an invalid input path.`);
+                // Even if it ends here, we still need to push the ID
+            }
+
+            resolvedPathParts.push(entityId); // Append entity ID
+            currentCollections = foundCollection.subcollections; // Move to subcollections
+            foundMatch = true;
+
+            if (!currentCollections && remainingPath.length > 0) {
+                // Warn if the path continues but no subcollections were defined
+                console.warn(`resolveCollectionPathIds: Path continues after entity ID "${entityId}", but no subcollections are defined for the preceding collection "${foundCollection.path}" in path "${path}". Appending remaining original path.`);
+                resolvedPathParts.push(remainingPath); // Append the rest
+                remainingPath = ""; // Stop processing
+                break;
+            }
+
+        }
+
+        if (!foundMatch) {
+            // Collection definition not found for the start of the remaining path
+            console.warn(`resolveCollectionPathIds: Collection definition not found for segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
+            resolvedPathParts.push(remainingPath); // Append the rest
+            remainingPath = ""; // Stop processing
+            break;
         }
-        const restOfThePath = cleanPath.split("/").slice(2).join("/");
-        return (resolvedAliased ?? subpaths[0]) + "/" + subpaths[1] + "/" + resolveCollectionPathIds(restOfThePath, segmentCollection.subcollections);
-    } else {
-        return resolvedAliased ?? cleanPath;
     }
+
+    return resolvedPathParts.join("/");
 }
 
 /**
@@ -116,6 +177,7 @@ export function navigateToEntity({
                                      entityId,
                                      copy,
                                      path,
+                                     fullIdPath,
                                      selectedTab,
                                      sideEntityController,
                                      onClose,
@@ -129,6 +191,7 @@ export function navigateToEntity({
                                      selectedTab?: string;
                                      copy?: boolean;
                                      path: string;
+                                     fullIdPath?: string;
                                      sideEntityController: SideEntityController;
                                      onClose?: () => void;
                                      navigation: NavigationController
@@ -138,7 +201,8 @@ export function navigateToEntity({
 
         sideEntityController.open({
             entityId,
-            path,
+            path: fullIdPath ?? path,
+            // fullIdPath,
             copy,
             selectedTab,
             collection,
@@ -147,7 +211,7 @@ export function navigateToEntity({
         });
 
     } else {
-        let to = navigation.buildUrlCollectionPath(entityId ? `${path}/${entityId}` : path);
+        let to = navigation.buildUrlCollectionPath(entityId ? `${fullIdPath ?? path}/${entityId}` : fullIdPath ?? path);
         if (entityId && selectedTab) {
             to += `/${selectedTab}`;
         }

package/src/util/objects.ts

@@ -12,28 +12,65 @@ export function isObject(item: any) {
     return item && typeof item === "object" && !Array.isArray(item);
 }
 
-export function mergeDeep<T extends Record<any, any>, U extends Record<any, any>>(target: T, source: U): T & U {
-    const targetIsObject = isObject(target);
-    const output = targetIsObject ? { ...target } : target;
-    if (targetIsObject && isObject(source)) {
-        Object.keys(source).forEach(key => {
-            const sourceElement = source[key];
-            if (sourceElement instanceof Date) {
-                // Assign a new Date instance with the same time value
-                Object.assign(output, { [key]: new Date(sourceElement.getTime()) });
-            } else if (isObject(sourceElement)) {
-                if (!(key in target))
-                    Object.assign(output, { [key]: sourceElement });
-                else
-                    (output as any)[key] = mergeDeep((target as any)[key], sourceElement);
+export function mergeDeep<T extends Record<any, any>, U extends Record<any, any>>(
+    target: T,
+    source: U,
+    ignoreUndefined: boolean = false
+): T & U {
+    // If target is not a true object (e.g., null, array, primitive), return target itself.
+    if (!isObject(target)) {
+        return target as T & U;
+    }
+
+    // Create a shallow copy of the target to avoid modifying the original object.
+    const output = { ...target };
+
+    // If source is not a true object, there's nothing to merge from it.
+    // Return the shallow copy of target.
+    if (!isObject(source)) {
+        return output as T & U;
+    }
+
+    // Iterate over keys in the source object.
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const sourceValue = source[key];
+            const outputValue = (output as any)[key]; // Current value in our merged object (originating from target)
+
+            // Skip if source value is undefined and ignoreUndefined is true.
+            // This handles both not adding new undefined properties and not overwriting existing properties with undefined.
+            if (ignoreUndefined && sourceValue === undefined) {
+                continue;
+            }
+
+            if ((sourceValue as any) instanceof Date) {
+                // If source value is a Date, create a new Date instance.
+                (output as any)[key] = new Date(sourceValue.getTime());
+            } else if (Array.isArray(sourceValue)) {
+                // If source value is an array, create a shallow copy of the array.
+                (output as any)[key] = [...sourceValue];
+            } else if (isObject(sourceValue)) {
+                // If source value is an object:
+                if (isObject(outputValue)) {
+                    // If the corresponding value in output (from target) is also an object, recurse.
+                    // Ensure the ignoreUndefined flag is passed down.
+                    (output as any)[key] = mergeDeep(outputValue, sourceValue, ignoreUndefined);
+                } else {
+                    // If output's value (from target) is not an object (e.g., null, primitive, or key didn't exist in original target),
+                    // overwrite with the source object.
+                    (output as any)[key] = sourceValue;
+                }
             } else {
-                Object.assign(output, { [key]: sourceElement });
+                // If source value is a primitive, null, or undefined (and not ignored).
+                (output as any)[key] = sourceValue;
             }
-        });
+        }
     }
-    return output as T;
+
+    return output as T & U;
 }
 
+
 export function getValueInPath(o: object | undefined, path: string): any {
     if (!o) return undefined;
     if (typeof o === "object") {

package/src/util/property_utils.tsx

@@ -1,6 +1,7 @@
 import React from "react";
 
 import {
+    AuthController,
     EntityCollection,
     PropertiesOrBuilders,
     PropertyConfig,
@@ -13,12 +14,15 @@ import { resolveProperty } from "./resolutions";
 import { CircleIcon, FunctionsIcon } from "@firecms/ui";
 import { getFieldConfig } from "../core";
 
-export function isReferenceProperty(propertyOrBuilder: PropertyOrBuilder,
-                                    fields: Record<string, PropertyConfig>) {
+export function isReferenceProperty(
+    authController: AuthController,
+    propertyOrBuilder: PropertyOrBuilder,
+    fields: Record<string, PropertyConfig>) {
     const resolvedProperty = resolveProperty({
         propertyKey: "ignore", // TODO
         propertyOrBuilder,
-        propertyConfigs: fields
+        propertyConfigs: fields,
+        authController
     });
     if (!resolvedProperty) return null;
     if (resolvedProperty.dataType === "reference") {

package/src/util/references.ts

@@ -1,12 +1,14 @@
-import { EntityCollection, PropertyConfig, ResolvedEntityCollection } from "../types";
+import { AuthController, EntityCollection, PropertyConfig, ResolvedEntityCollection } from "../types";
 import { isReferenceProperty } from "./property_utils";
 import { isPropertyBuilder } from "./entities";
 import { getFieldConfig } from "../core";
 
-export function getEntityPreviewKeys(targetCollection: EntityCollection<any>,
-                                     fields: Record<string, PropertyConfig>,
-                                     previewProperties?: string[],
-                                     limit = 3) {
+export function getEntityPreviewKeys(
+    authController: AuthController,
+    targetCollection: EntityCollection<any>,
+    fields: Record<string, PropertyConfig>,
+    previewProperties?: string[],
+    limit = 3) {
     const allProperties = Object.keys(targetCollection.properties);
     let listProperties = previewProperties?.filter(p => allProperties.includes(p as string));
     if (!listProperties && targetCollection.previewProperties) {
@@ -18,7 +20,7 @@ export function getEntityPreviewKeys(targetCollection: EntityCollection<any>,
         listProperties = allProperties;
         return listProperties.filter(key => {
             const propertyOrBuilder = targetCollection.properties[key];
-            return propertyOrBuilder && !isPropertyBuilder(propertyOrBuilder) && !isReferenceProperty(propertyOrBuilder, fields);
+            return propertyOrBuilder && !isPropertyBuilder(propertyOrBuilder) && !isReferenceProperty(authController, propertyOrBuilder, fields);
         }).slice(0, limit);
     }
 }

package/src/util/resolutions.ts

@@ -1,5 +1,6 @@
 import {
     ArrayProperty,
+    AuthController,
     CMSType,
     CustomizationController,
     EntityCollection,
@@ -27,9 +28,7 @@ import { getDefaultValuesFor, isPropertyBuilder } from "./entities";
 import { DEFAULT_ONE_OF_TYPE } from "./common";
 import { getIn } from "@firecms/formex";
 import { enumToObjectEntries } from "./enums";
-import { isDefaultFieldConfigId } from "../core/field_configs";
-
-// import util from "util";
+import { isDefaultFieldConfigId } from "../core";
 
 export const resolveCollection = <M extends Record<string, any>, >
 ({
@@ -40,7 +39,8 @@ export const resolveCollection = <M extends Record<string, any>, >
      previousValues,
      userConfigPersistence,
      propertyConfigs,
-     ignoreMissingFields = false
+     ignoreMissingFields = false,
+     authController
  }: {
     collection: EntityCollection<M> | ResolvedEntityCollection<M>;
     path: string,
@@ -50,6 +50,7 @@ export const resolveCollection = <M extends Record<string, any>, >
     userConfigPersistence?: UserConfigurationPersistence;
     propertyConfigs?: Record<string, PropertyConfig>;
     ignoreMissingFields?: boolean;
+    authController: AuthController;
 }): ResolvedEntityCollection<M> => {
 
     const collectionOverride = userConfigPersistence?.getCollectionConfig<M>(path);
@@ -69,7 +70,8 @@ export const resolveCollection = <M extends Record<string, any>, >
                 path,
                 entityId,
                 propertyConfigs: propertyConfigs,
-                ignoreMissingFields
+                ignoreMissingFields,
+                authController
             });
             if (!childResolvedProperty) return {};
             return ({
@@ -114,6 +116,7 @@ export function resolveProperty<T extends CMSType = CMSType, M extends Record<st
     fromBuilder?: boolean;
     propertyConfigs?: Record<string, PropertyConfig<any>>;
     ignoreMissingFields?: boolean;
+    authController: AuthController;
 }): ResolvedProperty<T> | null {
 
     if (typeof propertyOrBuilder === "object" && "resolved" in propertyOrBuilder) {
@@ -234,7 +237,8 @@ export function getArrayResolvedProperties<M>({
     entityId?: string;
     index?: number;
     fromBuilder?: boolean;
-    propertyConfigs?: Record<string, PropertyConfig>
+    propertyConfigs?: Record<string, PropertyConfig>;
+    authController: AuthController;
 }) {
 
     const of = property.of;
@@ -266,6 +270,7 @@ export function resolveArrayProperty<T extends any[], M>({
     fromBuilder?: boolean;
     propertyConfigs?: Record<string, PropertyConfig>;
     ignoreMissingFields?: boolean;
+    authController: AuthController;
 }): ResolvedArrayProperty {
     const propertyValue = propertyKey ? getIn(props.values, propertyKey) : undefined;
 
@@ -281,7 +286,7 @@ export function resolveArrayProperty<T extends any[], M>({
                         propertyOrBuilder: p as Property<any>,
                         ignoreMissingFields,
                         ...props,
-                        index
+                        index,
                     });
                 })
             } as ResolvedArrayProperty;
@@ -373,6 +378,7 @@ export function resolveProperties<M extends Record<string, any>>({
     fromBuilder?: boolean;
     propertyConfigs?: Record<string, PropertyConfig>;
     ignoreMissingFields?: boolean;
+    authController: AuthController;
 }): ResolvedProperties<M> {
     return Object.entries<PropertyOrBuilder>(properties as Record<string, PropertyOrBuilder>)
         .map(([key, property]) => {
@@ -435,11 +441,13 @@ export function resolveEntityView(entityView: string | EntityCustomView<any>, co
 export function resolvedSelectedEntityView<M extends Record<string, any>>(
     customViews: (string | EntityCustomView<M>)[] | undefined,
     customizationController: CustomizationController,
-    selectedTab?: string
+    selectedTab?: string,
+    canEdit?: boolean,
 ) {
     const resolvedEntityViews = customViews ? customViews
             .map(e => resolveEntityView(e, customizationController.entityViews))
-            .filter(Boolean) as EntityCustomView[]
+            .filter((e): e is EntityCustomView<M> => Boolean(e))
+            // .filter((e) => canEdit || !e.includeActions)
         : [];
 
     const selectedEntityView = resolvedEntityViews.find(e => e.key === selectedTab);

package/src/util/useStorageUploadController.tsx

@@ -18,6 +18,7 @@ import { PreviewSize } from "../preview";
 import { randomString } from "./strings";
 import { resolveStorageFilenameString, resolveStoragePathString } from "./storage";
 import { resolveProperty } from "./resolutions";
+import { useAuthController } from "../hooks";
 
 /**
  * Internal representation of an item in the storage
@@ -34,7 +35,6 @@ export interface StorageFieldItem {
     size: PreviewSize
 }
 
-
 export function useStorageUploadController<M extends object>({
                                                                  entityId,
                                                                  entityValues,
@@ -58,6 +58,7 @@ export function useStorageUploadController<M extends object>({
                                                                  onChange: (value: string | string[] | null) => void
                                                              }) {
 
+    const authController = useAuthController();
     const storage: StorageConfig | undefined = property.dataType === "string"
         ? property.storage
         : property.dataType === "array" &&
@@ -70,6 +71,8 @@ export function useStorageUploadController<M extends object>({
     if (!storage)
         throw Error("Storage meta must be specified");
 
+    const processFile = storage?.processFile;
+
     const metadata: Record<string, any> | undefined = storage?.metadata;
     const size = multipleFilesSupported ? "medium" : "large";
 
@@ -90,7 +93,8 @@ export function useStorageUploadController<M extends object>({
 
     const resolvedProperty = resolveProperty({
         propertyOrBuilder: property as PropertyOrBuilder,
-        values: entityValues
+        values: entityValues,
+        authController
     }) as ResolvedStringProperty | ResolvedArrayProperty<string[]>;
 
     const fileNameBuilder = useCallback(async (file: File) => {
@@ -170,7 +174,22 @@ export function useStorageUploadController<M extends object>({
         if (!acceptedFiles.length || disabled)
             return;
 
+        if (processFile) {
+            try {
+                acceptedFiles = await Promise.all(acceptedFiles.map(async file => {
+                    const processedFile = await processFile(file);
+                    if (!processedFile) {
+                        return file;
+                    }
+                    return processedFile;
+                }));
+            } catch (e) {
+                console.error("Error processing file with custom code. Attempting to continue uploading.", e);
+            }
+        }
+
         let newInternalValue: StorageFieldItem[];
+
         if (multipleFilesSupported) {
             newInternalValue = [...internalValue,
                 ...(await Promise.all(acceptedFiles.map(async file => {

package/dist/components/EntityCollectionTable/internal/popup_field/ElementResizeListener.d.ts

@@ -1,5 +0,0 @@
-interface Props {
-    onResize: (event: Event) => void;
-}
-export declare const ElementResizeListener: React.FC<Props>;
-export {};

package/src/components/EntityCollectionTable/internal/popup_field/ElementResizeListener.tsx

@@ -1,59 +0,0 @@
-import { RefObject, useCallback, useEffect, useRef } from "react";
-
-interface Props {
-    onResize: (event: Event) => void;
-}
-
-export const ElementResizeListener: React.FC<Props> = ({ onResize }) => {
-    const rafRef = useRef(0);
-    const objectRef: RefObject<HTMLObjectElement> = useRef(null);
-    const onResizeRef = useRef(onResize);
-
-    onResizeRef.current = onResize;
-
-    const _onResize = useCallback((e: Event) => {
-        if (rafRef.current) {
-            cancelAnimationFrame(rafRef.current);
-        }
-        rafRef.current = requestAnimationFrame(() => {
-            onResizeRef.current(e);
-        });
-    }, []);
-
-    const onLoad = useCallback(() => {
-        const obj = objectRef.current;
-        if (obj && obj.contentDocument && obj.contentDocument.defaultView) {
-            obj.contentDocument.defaultView.addEventListener("resize", _onResize);
-        }
-    }, [_onResize]);
-
-    useEffect(() => {
-        const obj = objectRef.current;
-        return () => {
-            if (obj && obj.contentDocument && obj.contentDocument.defaultView) {
-                obj.contentDocument.defaultView.removeEventListener("resize", _onResize);
-            }
-        };
-    }, [_onResize]);
-
-    return (
-        <object
-            onLoad={onLoad}
-            ref={objectRef}
-            tabIndex={-1}
-            type={"text/html"}
-            data={"about:blank"}
-            title={""}
-            style={{
-                position: "absolute",
-                top: 0,
-                left: 0,
-                height: "100%",
-                width: "100%",
-                pointerEvents: "none",
-                zIndex: -1,
-                opacity: 0
-            }}
-        />
-    );
-};