@evoke-platform/ui-components 1.13.0-dev.4 → 1.13.0-dev.6

package/dist/published/components/custom/CriteriaBuilder/PropertyTree.js

@@ -4,38 +4,25 @@ import { Autocomplete, RichTreeView } from '../../core';
 import { Box } from '../../layout';
 import { OverflowTextField } from '../OverflowTextField';
 import { PropertyTreeItem } from './PropertyTreeItem';
-import { findTreeItemById, truncateNamePath, updateTreeNode } from './utils';
+import { convertTreeViewPropertyToTreeItem, findTreeItemById, truncateNamePath, updateTreeViewProperty } from './utils';
 const NAME_PATH_LIMIT = 35;
 const PropertyTree = (props) => {
-    const { fetchObject, handleTreePropertySelect, rootObject, value, propertyTreeMap } = props;
+    const { fetchObject, handleTreePropertySelect, rootObject, setRootObject, value, propertyTreeMap } = props;
     const [options, setOptions] = useState([]);
     const [expandedItems, setExpandedItems] = useState([]);
     const [openDropdown, setOpenDropdown] = useState(false);
     useEffect(() => {
         // Transform rootObject properties to TreeItem format
-        setOptions(rootObject.properties.map((property) => ({
-            id: property.id,
-            label: property.name,
-            value: property.id,
-            type: property.type,
-            objectId: property.objectId,
-            children: property.children
-                ? property.children.map((child) => ({
-                    id: child.id,
-                    label: child.name,
-                    value: child.id,
-                    type: child.type,
-                    objectId: child.objectId,
-                }))
-                : undefined,
-        })));
-        setExpandedItems([]);
+        setOptions(rootObject.properties.map(convertTreeViewPropertyToTreeItem));
     }, [rootObject.properties]);
     const handleExpandedItemsChange = (e, itemIds) => {
         setExpandedItems(itemIds);
     };
     const handleUpdateNodeChildren = (nodeId, children) => {
-        setOptions((prevOptions) => updateTreeNode(prevOptions, nodeId, (node) => ({ ...node, children })));
+        setRootObject((prevObject) => ({
+            ...prevObject,
+            properties: updateTreeViewProperty(prevObject.properties, nodeId, (node) => ({ ...node, children })),
+        }));
     };
     return (React.createElement(Autocomplete, { "aria-label": "Property Selector", value: value, fullWidth: true, sx: { width: '37%' }, size: "small", disableClearable: true, options: options, open: openDropdown, onBlur: (e) => {
             const targetComponents = e.relatedTarget?.getAttribute('id')?.split('-');
@@ -58,11 +45,11 @@ const PropertyTree = (props) => {
         }, onFocus: () => setOpenDropdown(true), getOptionLabel: (option) => {
             // Retrieve the full name path from the map
             const namePath = typeof option === 'string'
-                ? ((propertyTreeMap[option] ?? '')?.name ?? option)
-                : (propertyTreeMap[option.value]?.name ?? option.value);
+                ? (propertyTreeMap[option] ?? '') || option
+                : propertyTreeMap[option.value] || option.value;
             return truncateNamePath(namePath, NAME_PATH_LIMIT);
         }, renderInput: (params) => {
-            const fullDisplayName = value && propertyTreeMap[value]?.name;
+            const fullDisplayName = value && propertyTreeMap[value];
             return (React.createElement(OverflowTextField, { ...params, "aria-label": fullDisplayName, value: fullDisplayName, placeholder: "Select a property" }));
         }, ListboxComponent: (props) => {
             return (React.createElement(ClickAwayListener, { onClickAway: (e) => {
@@ -73,8 +60,8 @@ const PropertyTree = (props) => {
                 } },
                 React.createElement(Box, { ...props },
                     React.createElement(RichTreeView, { sx: { width: '100%', paddingLeft: 0 }, role: "menu", "aria-label": "Property Tree", expandedItems: expandedItems, onExpandedItemsChange: handleExpandedItemsChange, items: options, slots: {
-                            item: (itemProps) => (React.createElement(PropertyTreeItem, { ...itemProps, items: options, expanded: expandedItems, setExpanded: setExpandedItems, fetchObject: fetchObject, updateNodeChildren: handleUpdateNodeChildren, handleTreePropertySelect: async (propertyId) => {
-                                    await handleTreePropertySelect(propertyId);
+                            item: (itemProps) => (React.createElement(PropertyTreeItem, { ...itemProps, items: options, expanded: expandedItems, setExpanded: setExpandedItems, fetchObject: fetchObject, updateNodeChildren: handleUpdateNodeChildren, handleTreePropertySelect: (propertyId) => {
+                                    handleTreePropertySelect(propertyId);
                                     setOpenDropdown(false);
                                 } })),
                         } }))));

package/dist/published/components/custom/CriteriaBuilder/PropertyTreeItem.d.ts

@@ -1,14 +1,13 @@
 import { TreeItemProps } from '@mui/x-tree-view';
 import React from 'react';
-import { Obj } from '../../../types';
-import { TreeItem } from './types';
+import { TreeItem, TreeViewObject, TreeViewProperty } from './types';
 type PropertyTreeItemProps = TreeItemProps & {
     items: TreeItem[];
     expanded: string[];
     setExpanded: (expanded: string[]) => void;
-    updateNodeChildren: (nodeId: string, children: TreeItem[]) => void;
-    fetchObject: (id: string) => Promise<Obj | undefined>;
-    handleTreePropertySelect: (propertyId: string) => Promise<void>;
+    updateNodeChildren: (nodeId: string, children: TreeViewProperty[]) => void;
+    fetchObject: (id: string) => Promise<TreeViewObject | undefined>;
+    handleTreePropertySelect: (propertyId: string) => void;
 };
 export declare const PropertyTreeItem: (props: PropertyTreeItemProps) => React.JSX.Element;
 export {};

package/dist/published/components/custom/CriteriaBuilder/PropertyTreeItem.js

@@ -11,35 +11,47 @@ export const PropertyTreeItem = (props) => {
             return;
         }
         const item = findTreeItemById(items, itemId);
-        if (item?.type === 'object') {
+        if (item?.type === 'loadingFailed') {
+            e.stopPropagation();
+            return;
+        }
+        if (item?.children) {
             e.stopPropagation();
             // If the item has an associated "objectId", fetch the properties of the object and expand the item.
-            if (item.objectId && item.children?.length === 1 && item.children[0].type === 'loading') {
-                const object = item.objectId ? await fetchObject(item.objectId) : undefined;
-                if (object) {
-                    updateNodeChildren(itemId, (object.properties ?? []).map((prop) => ({
-                        id: `${itemId}.${prop.id}`,
-                        label: prop.name,
-                        value: `${itemId}.${prop.id}`,
-                        type: prop.type,
-                        objectId: prop.objectId,
-                        children: prop.type === 'object'
-                            ? [
-                                {
-                                    id: `${itemId}.${prop.id}-loading`,
-                                    label: 'Loading...',
-                                    value: `${itemId}.${prop.id}-loading`,
-                                    type: 'loading',
-                                },
-                            ]
-                            : undefined,
-                    })));
+            if (item?.type === 'object' &&
+                item.objectId &&
+                item.children?.length === 1 &&
+                item.children[0].type === 'loading') {
+                try {
+                    const object = await fetchObject(item.objectId);
+                    if (object) {
+                        updateNodeChildren(itemId, object.properties
+                            .filter((prop) => prop.type !== 'collection')
+                            .map((prop) => ({
+                            ...prop,
+                            id: `${itemId}.${prop.id}`,
+                            children: prop.children?.map((child) => ({
+                                ...child,
+                                id: `${itemId}.${prop.id}.${child.id}`,
+                            })),
+                        })));
+                    }
+                }
+                catch (error) {
+                    updateNodeChildren(itemId, [
+                        {
+                            id: `${itemId}-failed`,
+                            name: 'Loading Failed',
+                            type: 'loadingFailed',
+                        },
+                    ]);
+                    console.error('Error fetching object:', error);
                 }
             }
             setExpanded([...expanded, itemId]);
             return;
         }
-        await handleTreePropertySelect(itemId);
+        handleTreePropertySelect(itemId);
     };
     return React.createElement(RichTreeItem, { itemId: itemId, label: label, children: children, onClick: onClick });
 };

package/dist/published/components/custom/CriteriaBuilder/types.d.ts

@@ -1,17 +1,8 @@
 /// <reference types="react" />
+import { Property } from '@evoke-platform/context';
 import { BaseSelectorProps } from 'react-querybuilder';
 import { ExpandedProperty } from '../../../types';
 import { AutocompleteOption, TreeViewBaseItem } from '../../core';
-export type ObjectProperty = {
-    id: string;
-    name: string;
-    type: string;
-    enum?: string[];
-    required?: boolean;
-    searchable?: boolean;
-    objectId?: string;
-    formula?: string;
-};
 export type CustomSelectorProps = BaseSelectorProps & {
     options: AutocompleteOption[] | any[];
     fieldData?: Record<string, any>;
@@ -28,7 +19,7 @@ export type PresetValue = {
     };
     type?: string;
 };
-export type TreeViewProperty = ObjectProperty & {
+export type TreeViewProperty = Property & {
     children?: TreeViewProperty[];
 };
 export type TreeViewObject = {

package/dist/published/components/custom/CriteriaBuilder/utils.d.ts

@@ -1,43 +1,16 @@
 import { Property } from '@evoke-platform/context';
 import { RuleGroupType } from 'react-querybuilder';
-import { Obj, ObjectProperty } from '../../../types';
-import { TreeItem } from './types';
+import { TreeItem, TreeViewProperty } from './types';
 /**
  * Recursively updates a node in a tree structure by applying an updater function to the node with the specified ID.
  *
- * @param {TreeItem[]} tree - The tree structure to update.
+ * @param {TreeViewProperty[]} tree - The tree structure to update.
  * @param {string} nodeId - The ID of the node to update.
- * @param {(node: TreeItem) => TreeItem} updater - The function to apply to the node.
- * @returns {TreeItem[]} - The updated tree structure.
+ * @param {(node: TreeViewProperty) => TreeViewProperty} updater - The function to apply to the node.
+ * @returns {TreeViewProperty[]} - The updated tree structure.
  */
-export declare const updateTreeNode: (tree: TreeItem[], nodeId: string, updater: (node: TreeItem) => TreeItem) => TreeItem[];
-type FetchObjectFunction = (id: string) => Promise<Obj | undefined>;
-/**
- * Fetches the display name path for a given property ID within an object hierarchy.
- *
- * @param {string} propertyId - The property ID to find the display name for.
- * @param {Obj} rootObject - The root object to start the search from.
- * @param {FetchObjectFunction} fetchObject - Function to fetch an object by its ID.
- * @returns {Promise<string>} - A promise that resolves to the display name path.
- */
-export declare const fetchDisplayNamePath: (propertyId: string, rootObject: Obj, fetchObject: FetchObjectFunction) => Promise<string>;
-/**
- * stores full dot-notation path to each property ID in the given array of properties.
- *
- * @param {ObjectProperty[]} properties - The array of properties to update.
- * @param {string} parentPath - The parent path to attach to each property ID.
- * @returns {ObjectProperty[]} The updated array of properties with the parent path attached to each property ID.
- */
-export declare const setIdPaths: (properties: ObjectProperty[], parentPath: string) => ObjectProperty[];
-/**
- * Traverses a property path within an object hierarchy to retrieve detailed property information.
- *
- * @param {string} propertyPath - The dot-separated path of the property to traverse.
- * @param {Obj} rootObject - The root object from which to start the traversal.
- * @param {FetchObjectFunction} fetchObject - A function to fetch an object by its ID.
- * @returns {Promise<ObjectProperty | null>} A promise that resolves to an ObjectProperty if found, or null otherwise.
- */
-export declare const traversePropertyPath: (propertyPath: string, rootObject: Obj, fetchObject: (objectId: string) => Promise<Obj | undefined>) => Promise<ObjectProperty | null>;
+export declare const updateTreeViewProperty: (tree: TreeViewProperty[], nodeId: string, updater: (node: TreeViewProperty) => TreeViewProperty) => TreeViewProperty[];
+export declare const convertTreeViewPropertyToTreeItem: (property: TreeViewProperty) => TreeItem;
 /**
  * Truncates the name path if it exceeds the specified character limit.
  *
@@ -68,4 +41,3 @@ export declare const ALL_OPERATORS: {
  */
 export declare const getReadableQuery: (mongoQuery?: Record<string, unknown>, properties?: Property[]) => string;
 export declare const findTreeItemById: (nodes: TreeItem[], nodeId: string) => TreeItem | null;
-export {};

package/dist/published/components/custom/CriteriaBuilder/utils.js

@@ -2,105 +2,32 @@ import { isArray, isEmpty, startCase } from 'lodash';
 /**
  * Recursively updates a node in a tree structure by applying an updater function to the node with the specified ID.
  *
- * @param {TreeItem[]} tree - The tree structure to update.
+ * @param {TreeViewProperty[]} tree - The tree structure to update.
  * @param {string} nodeId - The ID of the node to update.
- * @param {(node: TreeItem) => TreeItem} updater - The function to apply to the node.
- * @returns {TreeItem[]} - The updated tree structure.
+ * @param {(node: TreeViewProperty) => TreeViewProperty} updater - The function to apply to the node.
+ * @returns {TreeViewProperty[]} - The updated tree structure.
  */
-export const updateTreeNode = (tree, nodeId, updater) => {
+export const updateTreeViewProperty = (tree, nodeId, updater) => {
     return tree.map((node) => {
         if (node.id === nodeId) {
             return updater(node);
         }
         else if (node.children) {
-            return { ...node, children: updateTreeNode(node.children, nodeId, updater) };
+            return { ...node, children: updateTreeViewProperty(node.children, nodeId, updater) };
         }
         else {
             return node;
         }
     });
 };
-/**
- * Fetches the display name path for a given property ID within an object hierarchy.
- *
- * @param {string} propertyId - The property ID to find the display name for.
- * @param {Obj} rootObject - The root object to start the search from.
- * @param {FetchObjectFunction} fetchObject - Function to fetch an object by its ID.
- * @returns {Promise<string>} - A promise that resolves to the display name path.
- */
-export const fetchDisplayNamePath = async (propertyId, rootObject, fetchObject) => {
-    const propertyInfo = await traversePropertyPath(propertyId, rootObject, fetchObject);
-    return propertyInfo ? propertyInfo.name : '';
-};
-/**
- * stores full dot-notation path to each property ID in the given array of properties.
- *
- * @param {ObjectProperty[]} properties - The array of properties to update.
- * @param {string} parentPath - The parent path to attach to each property ID.
- * @returns {ObjectProperty[]} The updated array of properties with the parent path attached to each property ID.
- */
-export const setIdPaths = (properties, parentPath) => {
-    return properties.map((prop) => {
-        const fullPath = parentPath ? `${parentPath}.${prop.id}` : prop.id;
-        return {
-            ...prop,
-            id: fullPath,
-        };
-    });
-};
-/**
- * Traverses a property path within an object hierarchy to retrieve detailed property information.
- *
- * @param {string} propertyPath - The dot-separated path of the property to traverse.
- * @param {Obj} rootObject - The root object from which to start the traversal.
- * @param {FetchObjectFunction} fetchObject - A function to fetch an object by its ID.
- * @returns {Promise<ObjectProperty | null>} A promise that resolves to an ObjectProperty if found, or null otherwise.
- */
-export const traversePropertyPath = async (propertyPath, rootObject, fetchObject) => {
-    const segments = propertyPath.split('.');
-    let currentObject = rootObject;
-    let fullPath = '';
-    let namePath = '';
-    for (let i = 0; i < segments.length; i++) {
-        const remainingPath = segments.slice(i).join('.');
-        let prop = currentObject.properties?.find((p) => p.id === remainingPath);
-        if (prop) {
-            // flattened address or user properties
-            fullPath = fullPath ? `${fullPath}.${remainingPath}` : remainingPath;
-            namePath = namePath ? `${namePath} / ${prop.name}` : prop.name;
-            return {
-                ...prop,
-                id: fullPath,
-                name: namePath,
-            };
-        }
-        else {
-            prop = currentObject.properties?.find((p) => p.id === segments[i]);
-            if (!prop) {
-                return null;
-            }
-            fullPath = fullPath ? `${fullPath}.${prop.id}` : prop.id;
-            namePath = namePath ? `${namePath} / ${prop.name}` : prop.name;
-            if (i === segments.length - 1) {
-                return {
-                    ...prop,
-                    id: fullPath,
-                    name: namePath,
-                };
-            }
-            if (prop.type === 'object' && prop.objectId) {
-                const fetchedObject = await fetchObject(prop.objectId);
-                if (fetchedObject) {
-                    currentObject = fetchedObject;
-                }
-                else {
-                    return null;
-                }
-            }
-        }
-    }
-    return null;
-};
+export const convertTreeViewPropertyToTreeItem = (property) => ({
+    id: property.id,
+    label: property.name,
+    value: property.id,
+    type: property.type,
+    objectId: property.objectId,
+    children: property.children?.map(convertTreeViewPropertyToTreeItem),
+});
 /**
  * Truncates the name path if it exceeds the specified character limit.
  *
@@ -343,9 +270,11 @@ export const findTreeItemById = (nodes, nodeId) => {
     for (const node of nodes) {
         if (node.id === nodeId)
             return node;
-        const found = node.children && findTreeItemById(node.children, nodeId);
-        if (found)
-            return found;
+        if (nodeId.startsWith(node.id)) {
+            const found = node.children && findTreeItemById(node.children, nodeId);
+            if (found)
+                return found;
+        }
     }
     return null;
 };

package/dist/published/components/custom/Form/FormComponents/DocumentComponent/Document.js

@@ -43,7 +43,7 @@ export const Document = (props) => {
             // For 'file' type properties, check permissions on the sys__file object
             // For 'document' type properties, check document attachment permissions
             const endpoint = property.type === 'file'
-                ? getPrefixedUrl(`/objects/sys__file/instances/${instance.id}/checkAccess?action=update`)
+                ? getPrefixedUrl('/objects/sys__file/instances/checkAccess?action=execute&field=_create')
                 : getPrefixedUrl(`/objects/${objectId}/instances/${instance.id}/documents/checkAccess?action=update`);
             apiServices
                 .get(endpoint)

package/dist/published/components/custom/Form/FormComponents/DocumentComponent/DocumentList.js

@@ -64,12 +64,15 @@ export const DocumentList = (props) => {
     }, []);
     const checkPermissions = () => {
         if (instance?.[property.id]?.length) {
-            // For 'file' type properties, check permissions on the sys__file object
+            // For 'file' type properties, check regular object instance permissions
             // For 'document' type properties, check document attachment permissions
             const endpoint = property.type === 'file'
-                ? getPrefixedUrl(`/objects/sys__file/instances/${instance.id}/checkAccess?action=view`)
+                ? getPrefixedUrl(`/objects/sys__file/instances/checkAccess?action=read&field=content`)
                 : getPrefixedUrl(`/objects/${objectId}/instances/${instance.id}/documents/checkAccess?action=view`);
-            apiServices.get(endpoint).then((accessCheck) => setHasViewPermission(accessCheck.result));
+            apiServices
+                .get(endpoint)
+                .then((accessCheck) => setHasViewPermission(accessCheck.result))
+                .catch(() => setHasViewPermission(false));
         }
     };
     const isFile = (doc) => doc instanceof File;

package/dist/published/components/custom/Form/utils.d.ts

@@ -25,6 +25,7 @@ export declare function flattenFormComponents(components?: ActionInput[]): Actio
 export declare function addObjectPropertiesToComponentProps(properties: Property[], formComponents: any[], allCriteriaInputs?: string[], instance?: ObjectInstance, objectPropertyInputProps?: ObjectPropertyInputProps, associatedObject?: {
     instanceId?: string;
     propertyId?: string;
+    objectId?: string;
 }, autoSave?: (data: Record<string, unknown>) => void, readOnly?: boolean, defaultPages?: Record<string, string>, navigateTo?: (path: string) => void, queryAddresses?: (query: string) => Promise<Address[]>, apiServices?: ApiServices, isModal?: boolean, fieldHeight?: 'small' | 'medium', richTextEditor?: typeof ReactComponent): Promise<ActionInput[]>;
 export declare function getDefaultValue(initialValue: unknown, selectOptions?: AutocompleteOption[]): unknown;
 export declare const buildComponentPropsFromObjectProperties: (properties: Property[], objectId: string, instance?: ObjectInstance, objectPropertyInputProps?: ObjectPropertyInputProps, hasActionPermissions?: boolean, autoSave?: ((data: Record<string, unknown>) => void) | undefined, readOnly?: boolean, queryAddresses?: ((query: string) => Promise<Address[]>) | undefined, isModal?: boolean, fieldHeight?: 'small' | 'medium', richTextEditor?: typeof ReactComponent) => unknown[];

package/dist/published/components/custom/FormV2/FormRenderer.d.ts

@@ -21,6 +21,7 @@ export type FormRendererProps = BaseProps & {
     associatedObject?: {
         instanceId: string;
         propertyId: string;
+        objectId?: string;
     };
     renderHeader?: (props: HeaderProps) => React.ReactNode;
     renderBody?: (props: BodyProps) => React.ReactNode;

package/dist/published/components/custom/FormV2/FormRendererContainer.d.ts

@@ -31,6 +31,7 @@ export type FormRendererContainerProps = BaseProps & {
     associatedObject?: {
         instanceId: string;
         propertyId: string;
+        objectId?: string;
     };
     renderContainer?: (state: FormRendererState) => React.ReactNode;
     renderHeader?: FormRendererProps['renderHeader'];

package/dist/published/components/custom/FormV2/FormRendererContainer.js

@@ -158,7 +158,7 @@ function FormRendererContainer(props) {
         });
         if (navigationSlug) {
             if (navigationSlug.includes(':instanceId')) {
-                const navigateInstanceId = action?.type === 'create' ? updatedInstance?.id : instanceId;
+                const navigateInstanceId = action?.type === 'create' ? updatedInstance.id : instanceId;
                 navigateTo(`/${appId}/${navigationSlug.replace(':instanceId', navigateInstanceId ?? ':instanceId')}`);
             }
             else {
@@ -167,18 +167,17 @@ function FormRendererContainer(props) {
         }
         setInstance(updatedInstance);
     };
+    /**
+     * Manually links any newly uploaded files in the submission to the specified instance.
+     * @param submission The form submission data
+     * @param linkTo The instance to link the files to
+     */
     const linkFiles = async (submission, linkTo) => {
-        // Create file links for any uploaded files after instance creation
+        // Create file links for any uploaded files that haven't been linked yet
         for (const property of sanitizedObject?.properties?.filter((property) => property.type === 'file') ?? []) {
             const files = submission[property.id];
             if (files?.length) {
-                try {
-                    await createFileLinks(files, linkTo, apiServices);
-                }
-                catch (error) {
-                    console.error('Failed to create file links:', error);
-                    // Don't fail the entire submission if file linking fails
-                }
+                await createFileLinks(files, linkTo, apiServices);
             }
         }
     };
@@ -195,11 +194,9 @@ function FormRendererContainer(props) {
                         ?.filter((property) => property.formula || property.type === 'collection')
                         .map((property) => property.id) ?? []),
                 });
-                if (response) {
-                    // Manually link files to created instance.
-                    await linkFiles(submission, { id: response.id, objectId: form.objectId });
-                    onSubmissionSuccess(response);
-                }
+                // Manually link files to created instance.
+                await linkFiles(submission, { id: response.id, objectId: form.objectId });
+                onSubmissionSuccess(response);
             }
             else if (instanceId && action) {
                 const response = await objectStore.instanceAction(instanceId, {
@@ -209,21 +206,26 @@ function FormRendererContainer(props) {
                         .map((property) => property.id) ?? []),
                 });
                 if (sanitizedObject && instance) {
+                    if (!onAutosave) {
+                        // For non-autosave updates, link any uploaded files to the instance.
+                        await linkFiles(submission, { id: instanceId, objectId: objectId });
+                    }
                     onSubmissionSuccess(response);
-                    deleteDocuments(submission, true, apiServices, sanitizedObject, instance, action, setSnackbarError);
+                    // Only delete the necessary files after submission succeeds to avoid deleting a file prematurely.
+                    await deleteDocuments(submission, true, apiServices, sanitizedObject, instance, action, setSnackbarError);
                 }
             }
         }
         catch (error) {
-            // Handle deleteDocuments for uploaded documents if the main submission fails
-            if (instanceId && action && sanitizedObject && instance) {
-                deleteDocuments(submission, false, apiServices, sanitizedObject, instance, action, setSnackbarError);
-            }
             setSnackbarError({
                 isError: true,
                 showAlert: true,
                 message: error.response?.data?.error?.message ?? 'An error occurred',
             });
+            if (instanceId && action && sanitizedObject && instance) {
+                // For an update, uploaded documents have been linked to the instance and need to be deleted.
+                await deleteDocuments(submission, false, apiServices, sanitizedObject, instance, action, setSnackbarError);
+            }
             throw error; // Throw error so caller knows submission failed
         }
     };
@@ -255,10 +257,10 @@ function FormRendererContainer(props) {
                 const parameter = parameters?.find((param) => param.id === fieldId);
                 if (associatedObject?.propertyId === fieldId &&
                     associatedObject?.instanceId &&
-                    parameter &&
+                    (parameter || associatedObject.objectId) &&
                     action?.type === 'create') {
                     try {
-                        const instance = await apiServices.get(getPrefixedUrl(`/objects/${parameter.objectId}/instances/${associatedObject.instanceId}`));
+                        const instance = await apiServices.get(getPrefixedUrl(`/objects/${parameter?.objectId || associatedObject.objectId}/instances/${associatedObject.instanceId}`));
                         result[associatedObject.propertyId] = instance;
                     }
                     catch (error) {
@@ -327,7 +329,7 @@ function FormRendererContainer(props) {
         try {
             setIsSaving(true);
             const cleanedData = removeUneditedProtectedValues(formDataRef.current);
-            const submission = await formatSubmission(cleanedData, apiServices, objectId, instanceId, form, setSnackbarError);
+            const submission = await formatSubmission(cleanedData, apiServices, objectId, instanceId, form, setSnackbarError, undefined, parameters);
             // Handle object instance autosave
             if (instanceId && action?.type === 'update') {
                 await apiServices.post(getPrefixedUrl(`/objects/${objectId}/instances/${instanceId}/actions`), {
@@ -336,6 +338,7 @@ function FormRendererContainer(props) {
                         ?.filter((property) => !property.formula && property.type !== 'collection')
                         .map((property) => property.id) ?? []),
                 });
+                await linkFiles(submission, { id: instanceId, objectId });
             }
             setLastSavedData(cloneDeep(formDataRef.current));
             setIsSaving(false);

package/dist/published/components/custom/FormV2/components/FormContext.d.ts

@@ -23,6 +23,7 @@ type FormContextType = {
     associatedObject?: {
         instanceId: string;
         propertyId: string;
+        objectId?: string;
     };
     form?: EvokeForm;
     width: number;

package/dist/published/components/custom/FormV2/components/FormFieldTypes/CollectionFiles/ActionDialog.d.ts

@@ -13,6 +13,7 @@ export type ActionDialogProps = {
     associatedObject?: {
         instanceId: string;
         propertyId: string;
+        objectId?: string;
     };
 };
 export declare const ActionDialog: (props: ActionDialogProps) => React.JSX.Element;

package/dist/published/components/custom/FormV2/components/FormFieldTypes/DocumentFiles/Document.d.ts

@@ -1,12 +1,13 @@
 import { DocumentParameterValidation } from '@evoke-platform/context';
 import React from 'react';
-import { SavedDocumentReference } from '../../types';
+import { DocumentReference } from '../../types';
 type DocumentProps = {
     id: string;
+    fieldType?: 'file' | 'document';
     canUpdateProperty: boolean;
     error: boolean;
     validate?: DocumentParameterValidation;
-    value: (File | SavedDocumentReference)[] | undefined;
+    value: (File | DocumentReference)[] | undefined;
     hasDescription?: boolean;
 };
 export declare const Document: (props: DocumentProps) => React.JSX.Element;