@stackbit/cms-core 3.0.7 → 3.0.8

package/src/utils/custom-actions.ts

@@ -1,30 +1,34 @@
 import _ from 'lodash';
-import { Config } from '@stackbit/sdk';
+import { Config, PresetMap } from '@stackbit/sdk';
 import * as StackbitTypes from '@stackbit/types';
-import { mapPromise, omitByNil } from '@stackbit/utils';
+import { omitByNil } from '@stackbit/utils';
+import { v4 as uuid } from 'uuid';
 import * as ContentStoreTypes from '../types';
 import {
     CustomActionStateChange,
+    CustomActionRunStateMap,
+    CustomActionRunState,
     APICustomAction,
+    APICustomActionGlobal,
+    APICustomActionBulk,
+    APICustomActionModel,
+    APICustomActionModelSpecifier,
     APICustomActionDocumentSpecifier,
     APIGetCustomActionRequest,
+    APIGetRunningCustomActionsRequest,
     APIRunCustomActionRequest,
-    APIRunCustomActionRequestBulk,
-    CustomActionRunStateMap,
-    ExtendedCustomActionObjectModel,
-    ExtendedCustomActionField,
-    APICustomActionGlobal,
-    APICustomActionBulk,
+    APIRunCustomActionRequestModel,
+    APIRunCustomActionResponse,
     ExtendedCustomAction,
-    ExtendedCustomActionObjectField,
-    ExtendedCustomActionDocument
+    ExtendedCustomActionGlobal,
+    ExtendedCustomActionBulk,
+    ExtendedCustomActionModelGlobal
 } from '../types';
 import { createConfigDelegate } from './config-delegate';
 import { getContentSourceActionsForSourceThunk } from './document-hooks';
 import { mapStoreDocumentToCSIDocumentWithSource, mapStoreFieldToCSIField } from './store-to-csi-docs-converter';
 import { getModelAndDocumentFieldForLocalizedFieldPath } from './field-path-utils';
 import { getContentSourceDataByTypeAndProjectIdOrThrow, getUserContextForSrcTypeThunk } from '../content-store-utils';
-import { CustomActionBulk, CustomActionGlobal, CustomActionPermissions } from '@stackbit/types';
 
 export async function getGlobalAndBulkAPIActions({
     stackbitConfig,
@@ -44,7 +48,7 @@ export async function getGlobalAndBulkAPIActions({
     user?: ContentStoreTypes.User;
     locale?: string;
     currentPageDocument?: APICustomActionDocumentSpecifier;
-}): Promise<(APICustomActionGlobal | APICustomActionBulk)[]> {
+}): Promise<(APICustomActionGlobal | APICustomActionBulk | APICustomActionModel)[]> {
     if (!stackbitConfig || !Array.isArray(stackbitConfig.actions)) {
         return [];
     }
@@ -54,10 +58,9 @@ export async function getGlobalAndBulkAPIActions({
         logger: userLogger
     });
 
-    return mapPromise(stackbitConfig.actions, async (action) => {
+    const apiCustomActions: (APICustomActionGlobal | APICustomActionBulk | APICustomActionModel)[] = [];
+    for (const action of stackbitConfig.actions) {
         const actionId = globalActionId(action);
-        const actionRunState = customActionRunStateMap[actionId];
-        let state: StackbitTypes.CustomActionState | 'unknown';
         const pageDocument = getCSIDocumentWithSourceFromDocumentSpec(currentPageDocument, configDelegate);
         const commonStateOptions: StackbitTypes.CustomActionStateCommonOptions = {
             actionId: actionId,
@@ -68,36 +71,35 @@ export async function getGlobalAndBulkAPIActions({
             ...configDelegate
         };
 
-        if (actionRunState?.runningHandler) {
-            state = 'running';
-        } else if (action.state) {
-            state = await action.state(commonStateOptions);
-        } else {
-            state = actionRunState?.lastResultState ?? 'enabled';
-        }
+        const actionRunState = customActionRunStateMap[actionId];
 
-        let permissionsResult;
-        if (commonStateOptions.currentUser) {
-            const commonPermissionsOptions: StackbitTypes.CustomActionPermissionsCommonOptions = {
-                ..._.omit(commonStateOptions, ['currentUser']),
-                userContext: commonStateOptions.currentUser
-            };
+        const extendedAction = getExtendedActionFromGlobalAction({
+            action,
+            actionId,
+            actionRunState,
+            generateNewActionId: false
+        });
 
-            permissionsResult = resolveCustomActionPermissions({ action, commonPermissionsOptions, contentSourceDataById });
-        }
+        const state = await resolveCustomActionState({
+            extendedAction,
+            commonStateOptions
+        });
 
-        return omitByNil({
-            type: action.type,
-            actionId: actionId,
-            name: action.name,
-            label: action.label ?? _.startCase(action.name),
-            icon: action.icon,
-            state: state,
-            inputFields: action.inputFields,
-            hidden: action.hidden,
-            permissions: permissionsResult
+        const permissions = resolveCustomActionPermissions({
+            extendedAction,
+            commonStateOptions
         });
-    });
+
+        apiCustomActions.push(
+            extendedActionToApiAction({
+                extendedAction,
+                state,
+                permissions
+            })
+        );
+    }
+
+    return apiCustomActions;
 }
 
 export async function resolveCustomActionsById({
@@ -122,7 +124,7 @@ export async function resolveCustomActionsById({
     });
 
     for (const actionId of customActionIds) {
-        const extendedAction = findCustomActionById({
+        const extendedAction = getExtendedActionById({
             actionId,
             customActionRunStateMap,
             contentSourceDataById,
@@ -144,78 +146,20 @@ export async function resolveCustomActionsById({
         };
 
         try {
-            let state: StackbitTypes.CustomActionState;
-            if (extendedAction.runningHandler) {
-                state = 'running';
-            } else if (extendedAction.state) {
-                if (extendedAction.type === 'global' || extendedAction.type === 'bulk') {
-                    state = await extendedAction.state(commonStateOptions);
-                } else if (extendedAction.type === 'document') {
-                    const { document, model } = getCSIDocumentAndModelWithSourceFromDocumentSpec({
-                        documentSpec: extendedAction.documentSpec,
-                        contentSourceDataById
-                    });
-                    state = await extendedAction.state({
-                        ...commonStateOptions,
-                        document: document,
-                        model: model
-                    });
-                } else if (extendedAction.type === 'objectModel') {
-                    const stateObjectParams = getHandlerParamsForObjectModelAction({
-                        extendedAction,
-                        contentSourceDataById
-                    });
-                    state = await extendedAction.state({
-                        ...commonStateOptions,
-                        ...stateObjectParams
-                    });
-                } else if (extendedAction.type === 'objectField') {
-                    const stateObjectParams = getHandlerParamsForObjectFieldAction({
-                        extendedAction,
-                        contentSourceDataById
-                    });
-                    state = await extendedAction.state({
-                        ...commonStateOptions,
-                        ...stateObjectParams
-                    });
-                } else if (extendedAction.type === 'field') {
-                    const stateFieldParams = getHandlerParamsForFieldAction({
-                        extendedAction,
-                        contentSourceDataById
-                    });
-                    state = await extendedAction.state({
-                        ...commonStateOptions,
-                        ...stateFieldParams
-                    });
-                } else {
-                    const _exhaustiveCheck: never = extendedAction;
-                    continue;
-                }
-            } else {
-                state = extendedAction.lastResultState ?? 'enabled';
-            }
-
-            let permissionsResult;
-            if (commonStateOptions.currentUser) {
-                const commonPermissionsOptions: StackbitTypes.CustomActionPermissionsCommonOptions = {
-                    ..._.omit(commonStateOptions, ['currentUser']),
-                    userContext: commonStateOptions.currentUser
-                };
-
-                permissionsResult = resolveCustomActionPermissions({ action: extendedAction, commonPermissionsOptions, contentSourceDataById });
-            }
+            const state = await resolveCustomActionState({
+                extendedAction,
+                commonStateOptions
+            });
+            const permissions = resolveCustomActionPermissions({
+                extendedAction,
+                commonStateOptions
+            });
 
             result.push(
-                omitByNil({
-                    actionId: actionId,
-                    type: storeActionTypeToAPIActionType(extendedAction.type),
-                    name: extendedAction.name,
-                    label: extendedAction.label,
-                    icon: extendedAction.icon,
-                    state: state,
-                    inputFields: extendedAction.inputFields,
-                    hidden: extendedAction.hidden,
-                    permissions: permissionsResult
+                extendedActionToApiAction({
+                    extendedAction,
+                    state,
+                    permissions
                 })
             );
         } catch (error: any) {
@@ -226,103 +170,279 @@ export async function resolveCustomActionsById({
     return result;
 }
 
-export function resolveCustomActionPermissions({
-    action,
-    commonPermissionsOptions,
-    contentSourceDataById
+async function resolveCustomActionState({
+    extendedAction,
+    commonStateOptions
 }: {
-    action:
-        | CustomActionGlobal
-        | CustomActionBulk
-        | ExtendedCustomActionDocument
-        | ExtendedCustomActionObjectModel
-        | ExtendedCustomActionObjectField
-        | ExtendedCustomActionField;
-    commonPermissionsOptions: StackbitTypes.CustomActionPermissionsCommonOptions;
-    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
-}): CustomActionPermissions | undefined {
-    if (typeof action?.permissions !== 'function' || !commonPermissionsOptions.userContext) {
-        return undefined;
+    extendedAction: ExtendedCustomAction;
+    commonStateOptions: StackbitTypes.CustomActionStateCommonOptions;
+}): Promise<StackbitTypes.CustomActionState> {
+    if (extendedAction.isRunning) {
+        return 'running';
+    }
+
+    if (!('state' in extendedAction) || typeof extendedAction.state !== 'function') {
+        return 'enabled';
     }
 
-    let document, model, stateParams;
-    switch (action.type) {
+    switch (extendedAction.extendedType) {
         case 'global':
         case 'bulk':
-            return action.permissions?.(commonPermissionsOptions);
+            return await extendedAction.state(commonStateOptions);
         case 'document':
-            ({ document, model } = getCSIDocumentAndModelWithSourceFromDocumentSpec({
-                documentSpec: action.documentSpec,
-                contentSourceDataById
-            }));
-            return action.permissions?.({ ...commonPermissionsOptions, document, model });
+            return await extendedAction.state({
+                ...commonStateOptions,
+                document: extendedAction.documentWithSource,
+                model: extendedAction.modelWithSource
+            });
         case 'objectModel':
-            stateParams = getHandlerParamsForObjectModelAction({
-                extendedAction: action,
-                contentSourceDataById
+            return await extendedAction.state({
+                ...commonStateOptions,
+                parentDocument: extendedAction.documentWithSource,
+                parentModel: extendedAction.modelWithSource,
+                documentField: extendedAction.documentField,
+                modelField: extendedAction.modelField,
+                objectModel: extendedAction.objectModel,
+                fieldPath: extendedAction.fieldPath
             });
-            return action.permissions?.({ ...commonPermissionsOptions, ...stateParams });
         case 'objectField':
-            stateParams = getHandlerParamsForObjectFieldAction({
-                extendedAction: action,
-                contentSourceDataById
+            return await extendedAction.state({
+                ...commonStateOptions,
+                parentDocument: extendedAction.documentWithSource,
+                parentModel: extendedAction.modelWithSource,
+                documentField: extendedAction.documentField,
+                modelField: extendedAction.modelField,
+                fieldPath: extendedAction.fieldPath
             });
-            return action.permissions?.({ ...commonPermissionsOptions, ...stateParams });
         case 'field':
-            stateParams = getHandlerParamsForFieldAction({
-                extendedAction: action,
-                contentSourceDataById
+            return await extendedAction.state({
+                ...commonStateOptions,
+                parentDocument: extendedAction.documentWithSource,
+                parentModel: extendedAction.modelWithSource,
+                documentField: extendedAction.documentField,
+                modelField: extendedAction.modelField,
+                fieldPath: extendedAction.fieldPath
             });
-            return action.permissions?.({ ...commonPermissionsOptions, ...stateParams });
+        default: {
+            // actions of type 'model' do not support 'state' function
+            const _exhaustiveCheck: never = extendedAction;
+            throw new Error(`error getting action state, action of type '${_exhaustiveCheck['type']}' does not support states`);
+        }
     }
 }
 
-export function runCustomAction({
-    runActionRequest,
+function resolveCustomActionPermissions({
+    extendedAction,
+    commonStateOptions
+}: {
+    extendedAction: ExtendedCustomAction;
+    commonStateOptions: StackbitTypes.CustomActionStateCommonOptions;
+}): StackbitTypes.CustomActionPermissions | undefined {
+    if (typeof extendedAction?.permissions !== 'function' || !commonStateOptions.currentUser) {
+        return undefined;
+    }
+
+    const { currentUser, ...restOptions } = commonStateOptions;
+    const commonPermissionsOptions: StackbitTypes.CustomActionPermissionsCommonOptions = {
+        ...restOptions,
+        userContext: currentUser
+    };
+
+    switch (extendedAction.extendedType) {
+        case 'global':
+        case 'bulk':
+        case 'modelGlobal':
+        case 'model':
+        case 'modelObject': {
+            return extendedAction.permissions?.(commonPermissionsOptions);
+        }
+        case 'document': {
+            return extendedAction.permissions?.({
+                ...commonPermissionsOptions,
+                document: extendedAction.documentWithSource,
+                model: extendedAction.modelWithSource
+            });
+        }
+        case 'objectModel': {
+            return extendedAction.permissions?.({
+                ...commonPermissionsOptions,
+                parentDocument: extendedAction.documentWithSource,
+                parentModel: extendedAction.modelWithSource,
+                documentField: extendedAction.documentField,
+                modelField: extendedAction.modelField,
+                objectModel: extendedAction.objectModel,
+                fieldPath: extendedAction.fieldPath
+            });
+        }
+        case 'objectField': {
+            return extendedAction.permissions?.({
+                ...commonPermissionsOptions,
+                parentDocument: extendedAction.documentWithSource,
+                parentModel: extendedAction.modelWithSource,
+                documentField: extendedAction.documentField,
+                modelField: extendedAction.modelField,
+                fieldPath: extendedAction.fieldPath
+            });
+        }
+        case 'field': {
+            return extendedAction.permissions?.({
+                ...commonPermissionsOptions,
+                parentDocument: extendedAction.documentWithSource,
+                parentModel: extendedAction.modelWithSource,
+                documentField: extendedAction.documentField,
+                modelField: extendedAction.modelField,
+                fieldPath: extendedAction.fieldPath
+            });
+        }
+        default: {
+            const _exhaustiveCheck: never = extendedAction;
+            return _exhaustiveCheck;
+        }
+    }
+}
+
+export function getRunningActions({
+    getRunningActionsRequest,
     customActionRunStateMap,
     contentSourceDataById,
     stackbitConfig,
     userLogger
+}: {
+    getRunningActionsRequest: APIGetRunningCustomActionsRequest;
+    customActionRunStateMap: CustomActionRunStateMap;
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
+    stackbitConfig: Config | null;
+    userLogger: StackbitTypes.Logger;
+}): APICustomAction[] {
+    if (!getRunningActionsRequest.user) {
+        return [];
+    }
+    const runningActions: APICustomAction[] = [];
+    for (const [actionId, actionRunState] of Object.entries(customActionRunStateMap)) {
+        if (actionRunState.isRunning && actionRunState.userId === getRunningActionsRequest.user.id) {
+            const extendedAction = getExtendedActionById({
+                actionId,
+                customActionRunStateMap,
+                contentSourceDataById,
+                stackbitConfig
+            });
+            if (!extendedAction) {
+                userLogger.debug(`custom action with id: '${actionId}' was not found`);
+                continue;
+            }
+            runningActions.push(
+                extendedActionToApiAction({
+                    extendedAction,
+                    state: 'running'
+                })
+            );
+        }
+    }
+    return runningActions;
+}
+
+type ActionType = ExtendedCustomAction['type'];
+type ExtendedActionForActionType<Type extends ActionType, U extends ExtendedCustomAction = ExtendedCustomAction> = U extends { type: Type } ? U : never;
+type APICustomActionForType<Type extends ActionType, U extends APICustomAction = APICustomAction> = U extends { type: Type } ? U : never;
+
+function extendedActionToApiAction<Type extends ActionType>({
+    extendedAction,
+    state,
+    permissions
+}: {
+    extendedAction: ExtendedActionForActionType<Type>;
+    state: StackbitTypes.CustomActionState;
+    permissions?: StackbitTypes.CustomActionPermissions;
+}): APICustomActionForType<Type> {
+    const apiAction: APICustomAction = omitByNil({
+        type: extendedAction.type,
+        name: extendedAction.name,
+        label: extendedAction.label,
+        actionId: extendedAction.actionId,
+        userId: extendedAction.userId,
+        icon: extendedAction.icon,
+        state: state,
+        permissions: permissions,
+        models: extendedAction.extendedType === 'modelGlobal' && 'models' in extendedAction ? extendedAction.models : undefined,
+        inputFields: extendedAction.inputFields,
+        hidden: extendedAction.hidden
+    });
+    return apiAction as APICustomActionForType<Type>;
+}
+
+export async function runCustomAction({
+    runActionRequest,
+    customActionRunStateMap,
+    contentSourceDataById,
+    stackbitConfig,
+    userLogger,
+    presets,
+    onProgress
 }: {
     runActionRequest: APIRunCustomActionRequest;
     customActionRunStateMap: CustomActionRunStateMap;
     contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
     stackbitConfig: Config | null;
     userLogger: StackbitTypes.Logger;
-}): Promise<CustomActionStateChange> {
-    const extendedAction = findCustomActionById({
+    presets: PresetMap;
+    onProgress: (options: CustomActionStateChange) => void;
+}): Promise<APIRunCustomActionResponse> {
+    const extendedAction = getExtendedActionById({
         actionId: runActionRequest.actionId,
         customActionRunStateMap,
         contentSourceDataById,
-        stackbitConfig
+        stackbitConfig,
+        generateNewActionId: true
     });
     if (!extendedAction) {
         throw new Error(`Error running action: action not found, action name: '${runActionRequest.actionName}' action ID: '${runActionRequest.actionId}'.`);
     }
-    const prevResultState = extendedAction.lastResultState;
-    if (extendedAction.lastResultState && extendedAction.lastResultState !== 'enabled') {
-        throw new Error(
-            `Error running action: action is not enabled, action name: '${runActionRequest.actionName}' action ID: '${runActionRequest.actionId}'.`
-        );
+    if (extendedAction.isRunning) {
+        throw new Error(`Error running action: action '${runActionRequest.actionName}' with ID '${runActionRequest.actionId}' is already running.`);
     }
 
+    const actionId = extendedAction.actionId;
+    let isRunning = true;
+
     try {
         const actionLogger = userLogger.createLogger({ label: `action:${extendedAction.name}` });
         const configDelegate = createConfigDelegate({ contentSourceDataById: contentSourceDataById, logger: actionLogger });
         const currentPageDocument = getCSIDocumentWithSourceFromDocumentSpec(runActionRequest.currentPageDocument, configDelegate);
 
-        customActionRunStateMap[runActionRequest.actionId] = {
-            runningHandler: true,
-            lastResultState: 'running'
+        const actionRunState: CustomActionRunState = {
+            isRunning: true,
+            userId: runActionRequest.user?.id
         };
+        customActionRunStateMap[actionId] = actionRunState;
+
+        const inputData = runActionRequest.inputData ?? {};
+        if (runActionRequest.actionType === 'model' && 'presetId' in runActionRequest) {
+            inputData.presetData = presets[runActionRequest.presetId!]?.data;
+        }
 
         const commonRunOptions: StackbitTypes.CustomActionRunCommonOptions = {
-            actionId: extendedAction.actionId,
-            inputData: runActionRequest.inputData,
+            actionId: actionId,
+            inputData: inputData,
             currentLocale: runActionRequest.locale,
             currentUser: runActionRequest.user,
             currentPageUrl: runActionRequest.pageUrl,
             currentPageDocument: currentPageDocument,
+            progress: ({ message, percent }) => {
+                if (!isRunning) {
+                    return;
+                }
+                onProgress(
+                    omitByNil({
+                        actionId: actionId,
+                        actionName: extendedAction.name,
+                        actionType: extendedAction.type,
+                        userId: runActionRequest.user?.id,
+                        state: 'running',
+                        message,
+                        percent
+                    })
+                );
+            },
             getContentSourceActionsForSource: getContentSourceActionsForSourceThunk({
                 getContentSourceDataById: () => contentSourceDataById,
                 logger: userLogger,
@@ -335,10 +455,15 @@ export function runCustomAction({
 
         let promise: Promise<StackbitTypes.CustomActionResult | void>;
 
-        if (extendedAction.type === 'global') {
+        if (extendedAction.extendedType === 'global') {
             promise = extendedAction.run(commonRunOptions);
-        } else if (extendedAction.type === 'bulk') {
-            const documents = (runActionRequest as APIRunCustomActionRequestBulk).documents.map((documentSpec) => {
+        } else if (extendedAction.extendedType === 'bulk') {
+            if (!('documents' in runActionRequest) || !Array.isArray(runActionRequest.documents)) {
+                throw new Error(
+                    `Bulk action run request must contain array of documents, action name: '${runActionRequest.actionName}', action ID: '${runActionRequest.actionId}'.`
+                );
+            }
+            const documents = runActionRequest.documents.map((documentSpec) => {
                 const { document } = getCSIDocumentAndModelWithSourceFromDocumentSpec({
                     documentSpec,
                     contentSourceDataById
@@ -349,74 +474,140 @@ export function runCustomAction({
                 ...commonRunOptions,
                 documents
             });
-        } else if (extendedAction.type === 'document') {
-            const { document, model } = getCSIDocumentAndModelWithSourceFromDocumentSpec({
-                documentSpec: extendedAction.documentSpec,
-                contentSourceDataById
+        } else if (extendedAction.extendedType === 'modelGlobal') {
+            if (!('srcType' in runActionRequest) || !('srcProjectId' in runActionRequest) || !('modelName' in runActionRequest)) {
+                throw new Error(
+                    `Global model action run request must contain srcType, srcProjectId and modelName, action name: '${runActionRequest.actionName}', action ID: '${runActionRequest.actionId}'.`
+                );
+            }
+            actionRunState.modelSpec = {
+                srcType: runActionRequest.srcType,
+                srcProjectId: runActionRequest.srcProjectId,
+                modelName: runActionRequest.modelName
+            };
+            const runOptions = getRunParamsForModelAction({
+                modelSpec: actionRunState.modelSpec,
+                location: runActionRequest.location,
+                contentSourceDataById,
+                getContentSourceActionsForSource: commonRunOptions.getContentSourceActionsForSource
+            });
+            promise = extendedAction.run({
+                ...commonRunOptions,
+                ...runOptions
+            });
+        } else if (extendedAction.extendedType === 'model') {
+            const runOptions = getRunParamsForModelAction({
+                modelSpec: extendedAction.modelSpec,
+                location: (runActionRequest as APIRunCustomActionRequestModel).location,
+                contentSourceDataById,
+                getContentSourceActionsForSource: commonRunOptions.getContentSourceActionsForSource
             });
             promise = extendedAction.run({
                 ...commonRunOptions,
-                document,
-                model,
+                ...runOptions
+            });
+        } else if (extendedAction.extendedType === 'document') {
+            promise = extendedAction.run({
+                ...commonRunOptions,
+                document: extendedAction.documentWithSource,
+                model: extendedAction.modelWithSource,
                 contentSourceActions: commonRunOptions.getContentSourceActionsForSource({
-                    srcType: extendedAction.documentSpec.srcType,
-                    srcProjectId: extendedAction.documentSpec.srcProjectId
+                    srcType: extendedAction.documentWithSource.srcType,
+                    srcProjectId: extendedAction.documentWithSource.srcProjectId
                 })!
             });
-        } else if (extendedAction.type === 'objectModel') {
-            const handlerObjectParams = getHandlerParamsForObjectModelAction({
-                extendedAction,
-                contentSourceDataById
-            });
+        } else if (extendedAction.extendedType === 'modelObject') {
             promise = extendedAction.run({
                 ...commonRunOptions,
-                ...handlerObjectParams,
+                parentDocument: extendedAction.documentWithSource,
+                parentModel: extendedAction.modelWithSource,
+                modelField: extendedAction.modelField,
+                objectModel: extendedAction.objectModel,
+                fieldPath: extendedAction.fieldPath,
+                location: (runActionRequest as APIRunCustomActionRequestModel).location,
                 contentSourceActions: commonRunOptions.getContentSourceActionsForSource({
-                    srcType: extendedAction.documentSpec.srcType,
-                    srcProjectId: extendedAction.documentSpec.srcProjectId
+                    srcType: extendedAction.documentWithSource.srcType,
+                    srcProjectId: extendedAction.documentWithSource.srcProjectId
                 })!
             });
-        } else if (extendedAction.type === 'objectField') {
-            const handlerObjectParams = getHandlerParamsForObjectFieldAction({
-                extendedAction,
-                contentSourceDataById
+        } else if (extendedAction.extendedType === 'objectModel') {
+            promise = extendedAction.run({
+                ...commonRunOptions,
+                parentDocument: extendedAction.documentWithSource,
+                parentModel: extendedAction.modelWithSource,
+                documentField: extendedAction.documentField,
+                modelField: extendedAction.modelField,
+                objectModel: extendedAction.objectModel,
+                fieldPath: extendedAction.fieldPath,
+                contentSourceActions: commonRunOptions.getContentSourceActionsForSource({
+                    srcType: extendedAction.documentWithSource.srcType,
+                    srcProjectId: extendedAction.documentWithSource.srcProjectId
+                })!
             });
+        } else if (extendedAction.extendedType === 'objectField') {
             promise = extendedAction.run({
                 ...commonRunOptions,
-                ...handlerObjectParams,
+                parentDocument: extendedAction.documentWithSource,
+                parentModel: extendedAction.modelWithSource,
+                documentField: extendedAction.documentField,
+                modelField: extendedAction.modelField,
+                fieldPath: extendedAction.fieldPath,
                 contentSourceActions: commonRunOptions.getContentSourceActionsForSource({
-                    srcType: extendedAction.documentSpec.srcType,
-                    srcProjectId: extendedAction.documentSpec.srcProjectId
+                    srcType: extendedAction.documentWithSource.srcType,
+                    srcProjectId: extendedAction.documentWithSource.srcProjectId
                 })!
             });
-        } else if (extendedAction.type === 'field') {
-            const handlerFieldParams = getHandlerParamsForFieldAction({ extendedAction, contentSourceDataById });
+        } else if (extendedAction.extendedType === 'field') {
             promise = extendedAction.run({
                 ...commonRunOptions,
-                ...handlerFieldParams,
+                parentDocument: extendedAction.documentWithSource,
+                parentModel: extendedAction.modelWithSource,
+                documentField: extendedAction.documentField,
+                modelField: extendedAction.modelField,
+                fieldPath: extendedAction.fieldPath,
                 contentSourceActions: commonRunOptions.getContentSourceActionsForSource({
-                    srcType: extendedAction.documentSpec.srcType,
-                    srcProjectId: extendedAction.documentSpec.srcProjectId
+                    srcType: extendedAction.documentWithSource.srcType,
+                    srcProjectId: extendedAction.documentWithSource.srcProjectId
                 })!
             });
         } else {
-            throw new Error(`action type ${(extendedAction as any).type} not supported`);
+            const _exhaustiveCheck: never = extendedAction;
+            throw new Error(`action of type ${_exhaustiveCheck['type']} is not supported`);
         }
 
-        return promise
-            .then((actionResult) => {
-                customActionRunStateMap[runActionRequest.actionId] = {
-                    runningHandler: false,
-                    lastResultState: actionResult?.state
-                };
-                userLogger.debug(`Action completed: ${extendedAction.actionId}`);
-                return Promise.resolve(
+        onProgress(
+            omitByNil({
+                actionId: actionId,
+                actionName: extendedAction.name,
+                actionType: extendedAction.type,
+                userId: runActionRequest.user?.id,
+                state: 'running'
+            })
+        );
+
+        promise
+            .then(async (actionResult) => {
+                isRunning = false;
+                delete customActionRunStateMap[actionId];
+                userLogger.debug(`Action completed: ${actionId}`);
+                const state = await resolveCustomActionState({
+                    extendedAction,
+                    commonStateOptions: {
+                        actionId: actionId,
+                        currentLocale: runActionRequest.locale,
+                        currentUser: runActionRequest.user,
+                        currentPageUrl: runActionRequest.pageUrl,
+                        currentPageDocument: currentPageDocument,
+                        ...configDelegate
+                    }
+                });
+                onProgress(
                     omitByNil({
-                        actionId: extendedAction.actionId,
+                        actionId: actionId,
                         actionName: extendedAction.name,
-                        actionType: storeActionTypeToAPIActionType(extendedAction.type),
-                        // TODO: resolve the state if state function is defined
-                        state: actionResult?.state ?? 'enabled',
+                        actionType: extendedAction.type,
+                        userId: runActionRequest.user?.id,
+                        state: extendedAction.type === 'model' ? 'finished' : state,
                         success: actionResult?.success,
                         error: actionResult?.error,
                         result: actionResult?.result
@@ -424,37 +615,29 @@ export function runCustomAction({
                 );
             })
             .catch((error: any) => {
-                customActionRunStateMap[runActionRequest.actionId] = {
-                    runningHandler: false,
-                    lastResultState: prevResultState
-                };
-                userLogger.debug(`Error running action: ${error.message}`);
-                return Promise.resolve({
-                    actionId: extendedAction.actionId,
-                    actionName: extendedAction.name,
-                    actionType: storeActionTypeToAPIActionType(extendedAction.type),
-                    // TODO: resolve the state if state function is defined
-                    state: prevResultState ?? 'enabled',
-                    error: `Error running action: ${error.message}`
-                });
+                isRunning = false;
+                delete customActionRunStateMap[actionId];
+                userLogger.warn(`Error running action: ${error.stack ?? error.message}`);
+                onProgress(
+                    omitByNil({
+                        actionId: extendedAction.actionId,
+                        actionName: extendedAction.name,
+                        actionType: extendedAction.type,
+                        userId: runActionRequest.user?.id,
+                        state: extendedAction.type === 'model' ? 'failed' : 'enabled',
+                        error: `Error running action: ${error.message}`
+                    })
+                );
             });
     } catch (error: any) {
-        if (customActionRunStateMap[runActionRequest.actionId]) {
-            customActionRunStateMap[runActionRequest.actionId] = {
-                runningHandler: false,
-                lastResultState: prevResultState
-            };
-        }
-        userLogger.debug(`Error running action: ${error.message}`);
-        return Promise.resolve({
-            actionId: runActionRequest.actionId,
-            actionName: extendedAction?.name ?? runActionRequest.actionName,
-            actionType: storeActionTypeToAPIActionType(extendedAction?.type) ?? runActionRequest.actionType,
-            // TODO: resolve the state if state function is defined
-            state: prevResultState ?? 'enabled',
-            error: `Error running action: ${error.message}`
-        });
+        isRunning = false;
+        delete customActionRunStateMap[actionId];
+        userLogger.warn(`Error running action: ${error.stack ?? error.message}`);
+        // rethrow the error to return erroneous response
+        throw error;
     }
+
+    return { actionId };
 }
 
 function getCSIDocumentWithSourceFromDocumentSpec(
@@ -470,112 +653,34 @@ function getCSIDocumentWithSourceFromDocumentSpec(
         : undefined;
 }
 
-function getHandlerParamsForObjectModelAction({
-    extendedAction,
-    contentSourceDataById
-}: {
-    extendedAction: Pick<ExtendedCustomActionObjectModel, 'documentSpec' | 'fieldPath'>;
-    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
-}): StackbitTypes.CustomActionObjectModelStateParams {
-    const fieldActionCommonParams = getHandlerParamsForFieldAction({
-        extendedAction,
-        contentSourceDataById
-    });
-
-    if (!fieldActionCommonParams.documentField) {
-        throw new Error(`object document field not found at field path: ${extendedAction.fieldPath.join('.')}`);
-    }
-
-    const documentField = fieldActionCommonParams.documentField as StackbitTypes.DocumentModelFieldNonLocalized;
-    const documentSpec = extendedAction.documentSpec;
-    const contentSourceData = getContentSourceDataByTypeAndProjectIdOrThrow(documentSpec.srcType, documentSpec.srcProjectId, contentSourceDataById);
-    const objectModel = contentSourceData.modelMap[documentField.modelName];
-    if (!objectModel || objectModel.type !== 'object') {
-        throw new Error(`object model '${documentField.modelName}' not found`);
-    }
-
-    return {
-        ...fieldActionCommonParams,
-        documentField,
-        modelField: fieldActionCommonParams.modelField as StackbitTypes.FieldModel,
-        objectModel: {
-            ...objectModel,
-            srcType: documentSpec.srcType,
-            srcProjectId: documentSpec.srcProjectId
-        }
-    };
-}
-
-function getHandlerParamsForObjectFieldAction({
-    extendedAction,
-    contentSourceDataById
-}: {
-    extendedAction: Pick<ExtendedCustomActionObjectField, 'documentSpec' | 'fieldPath'>;
-    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
-}): StackbitTypes.CustomActionObjectFieldStateParams {
-    const fieldActionCommonParams = getHandlerParamsForFieldAction({
-        extendedAction,
-        contentSourceDataById
-    });
-
-    if (!fieldActionCommonParams.documentField) {
-        throw new Error(`object document field not found at field path: ${extendedAction.fieldPath.join('.')}`);
-    }
-
-    return {
-        ...fieldActionCommonParams,
-        documentField: fieldActionCommonParams.documentField as StackbitTypes.DocumentObjectFieldNonLocalized,
-        modelField: fieldActionCommonParams.modelField as StackbitTypes.FieldObject
-    };
-}
-
-function getHandlerParamsForFieldAction({
-    extendedAction,
-    contentSourceDataById
+function getRunParamsForModelAction({
+    modelSpec,
+    location,
+    contentSourceDataById,
+    getContentSourceActionsForSource
 }: {
-    extendedAction: Pick<ExtendedCustomActionField, 'documentSpec' | 'fieldPath'>;
+    modelSpec: APICustomActionModelSpecifier;
+    location: 'new-card' | 'preset-card';
     contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
-}): StackbitTypes.CustomActionFieldStateParams {
-    const documentSpec = extendedAction.documentSpec;
-    const contentSourceData = getContentSourceDataByTypeAndProjectIdOrThrow(documentSpec.srcType, documentSpec.srcProjectId, contentSourceDataById);
-    const document = contentSourceData.documentMap[documentSpec.srcDocumentId];
-    const csiDocument = contentSourceData.csiDocumentMap[documentSpec.srcDocumentId];
-    if (!document || !csiDocument) {
-        throw new Error(
-            `document not found for srcType: ${documentSpec.srcType}, srcProjectId: ${documentSpec.srcProjectId}, srcDocumentId: ${documentSpec.srcDocumentId}`
-        );
-    }
-
-    const model = contentSourceData.modelMap[document.srcModelName];
-    if (!model) {
-        throw new Error(`model '${document.srcModelName}' not found`);
+    getContentSourceActionsForSource: ReturnType<typeof getContentSourceActionsForSourceThunk>;
+}): StackbitTypes.CustomActionModelRunOptions {
+    const { srcType, srcProjectId, modelName } = modelSpec;
+    const contentSourceData = getContentSourceDataByTypeAndProjectIdOrThrow(srcType, srcProjectId, contentSourceDataById);
+    const actionModel = contentSourceData.modelMap[modelName];
+    if (!actionModel) {
+        throw new Error(`model '${modelName}' not found`);
     }
-
-    const mappedCSIDocument = mapStoreDocumentToCSIDocumentWithSource({ document, csiDocument });
-
-    // the documentField should be localized because fieldPath includes locales
-    const { modelField, documentField } = getModelAndDocumentFieldForLocalizedFieldPath({
-        document,
-        fieldPath: extendedAction.fieldPath,
-        modelMap: contentSourceData.modelMap
-    }) as {
-        // list items cannot have actions, therefore we can safely reduce the type to non list item fields
-        modelField: StackbitTypes.Field;
-        documentField?: ContentStoreTypes.DocumentField;
-    };
-
-    const csiDocumentField = documentField ? mapStoreFieldToCSIField(documentField) : undefined;
-
     return {
-        parentDocument: mappedCSIDocument,
-        parentModel: {
-            ...model,
-            srcType: documentSpec.srcType,
-            srcProjectId: documentSpec.srcProjectId
+        actionModel: {
+            ...actionModel,
+            srcType,
+            srcProjectId
         },
-        documentField: csiDocumentField,
-        modelField: modelField,
-        fieldPath: extendedAction.fieldPath
+        location,
+        contentSourceActions: getContentSourceActionsForSource({
+            srcType,
+            srcProjectId
+        })!
     };
 }
 
@@ -597,16 +702,16 @@ function getCSIDocumentAndModelWithSourceFromDocumentSpec({
             `document not found, srcType: ${documentSpec.srcType}, srcProjectId: ${documentSpec.srcProjectId}, srcDocumentId: ${documentSpec.srcDocumentId}`
         );
     }
-    const mappedDocument = mapStoreDocumentToCSIDocumentWithSource({
+    const documentWithSource = mapStoreDocumentToCSIDocumentWithSource({
         document,
         csiDocument
     });
-    const model = contentSourceData.modelMap[mappedDocument.modelName];
+    const model = contentSourceData.modelMap[documentWithSource.modelName];
     if (!model) {
-        throw new Error(`model '${mappedDocument.modelName}' not found`);
+        throw new Error(`model '${documentWithSource.modelName}' not found`);
     }
     return {
-        document: mappedDocument,
+        document: documentWithSource,
         model: {
             ...model,
             srcType: documentSpec.srcType,
@@ -615,25 +720,23 @@ function getCSIDocumentAndModelWithSourceFromDocumentSpec({
     };
 }
 
-function storeActionTypeToAPIActionType(storeActionType: ExtendedCustomAction['type']): APICustomAction['type'] {
-    if (storeActionType === 'objectModel' || storeActionType === 'objectField') {
-        return 'object';
-    }
-    return storeActionType;
-}
-
-function findCustomActionById({
+function getExtendedActionById({
     actionId,
     customActionRunStateMap,
     contentSourceDataById,
-    stackbitConfig
+    stackbitConfig,
+    generateNewActionId
 }: {
     actionId: string;
     customActionRunStateMap: CustomActionRunStateMap;
     contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
     stackbitConfig: Config | null;
+    generateNewActionId?: boolean;
 }): ExtendedCustomAction | undefined {
     const actionRunState = customActionRunStateMap[actionId];
+
+    // Check if this is a global action defined in the actions array of stackbit.config.
+    // Their types can be "global", "bulk" or "model"
     if (isGlobalActionId(actionId)) {
         if (!stackbitConfig || !Array.isArray(stackbitConfig.actions)) {
             return undefined;
@@ -643,105 +746,241 @@ function findCustomActionById({
         if (!action) {
             return undefined;
         }
+        return getExtendedActionFromGlobalAction({
+            action,
+            actionId,
+            actionRunState,
+            generateNewActionId
+        });
+    }
+
+    const { srcType, srcProjectId, modelName, srcDocumentId, fieldPath, actionName } = parseActionId(actionId) ?? {};
+    if (!srcType || !srcProjectId || !actionName) {
+        return undefined;
+    }
+    const contentSourceData = getContentSourceDataByTypeAndProjectIdOrThrow(srcType, srcProjectId, contentSourceDataById);
+
+    // If "modelName" was specified without "srcDocumentId" then it has to be a
+    // "model" action defined in a model of type 'page' or 'data'.
+    if (!srcDocumentId && modelName) {
+        const model = contentSourceData.modelMap[modelName];
+        if (!model || (model.type !== 'page' && model.type !== 'data')) {
+            return undefined;
+        }
+        const action = model.actions?.find((action) => action.name === actionName);
+        if (!action || action.type !== 'model') {
+            return undefined;
+        }
         return {
             ...action,
-            actionId,
-            label: action.label ?? _.startCase(action.name),
-            runningHandler: actionRunState?.runningHandler,
-            lastResultState: actionRunState?.lastResultState
+            extendedType: 'model',
+            actionId:
+                generateNewActionId && !actionRunState
+                    ? JSON.stringify({
+                          srcType,
+                          srcProjectId,
+                          modelName,
+                          actionName,
+                          actionRunId: uuid().substring(0, 8)
+                      })
+                    : actionId,
+            label: getActionLabel(action),
+            modelSpec: { srcType, srcProjectId, modelName },
+            userId: actionRunState?.userId,
+            isRunning: actionRunState?.isRunning
         };
     }
-    const { srcType, srcProjectId, srcDocumentId, actionName, fieldPath } = parseActionId(actionId) ?? {};
-    if (!srcType || !srcProjectId || !srcDocumentId || !actionName) {
+
+    if (!srcDocumentId) {
         return undefined;
     }
-    const documentSpec: APICustomActionDocumentSpecifier = { srcType, srcProjectId, srcDocumentId };
-    const contentSourceData = getContentSourceDataByTypeAndProjectIdOrThrow(srcType, srcProjectId, contentSourceDataById);
     const document = contentSourceData.documentMap[srcDocumentId];
-    if (!document) {
+    const csiDocument = contentSourceData.csiDocumentMap[srcDocumentId];
+    if (!document || !csiDocument) {
         return undefined;
     }
-    const modelName = document.srcModelName;
-    const model = contentSourceData.modelMap[modelName];
+
+    const model = contentSourceData.modelMap[document.srcModelName];
     // The model of a document is always 'page' or 'data',
-    // this condition helps TS to infer the right type of model.actions
+    // this condition helps Typescript infer the right type of model.actions
     if (!model || (model.type !== 'page' && model.type !== 'data')) {
         return undefined;
     }
+    const documentWithSource = mapStoreDocumentToCSIDocumentWithSource({
+        document,
+        csiDocument
+    });
+    const modelWithSource = { ...model, srcType, srcProjectId };
     if (typeof fieldPath === 'undefined') {
-        // fieldPath was not provided, therefore the model must be of type "page" or "data",
-        // and the action type must be 'document'
+        // If fieldPath was not provided, then the model must be of type "page" or "data",
+        // and the action type must be of type 'document'
         const action = model.actions?.find((action) => action.name === actionName);
-        if (!action) {
+        if (!action || action.type !== 'document') {
             return undefined;
         }
         return {
             // if configuration is updated, the new action properties will override the stored action properties
             ...action,
             type: 'document',
+            extendedType: 'document',
             actionId,
-            label: action.label ?? _.startCase(action.name),
-            documentSpec,
-            runningHandler: actionRunState?.runningHandler,
-            lastResultState: actionRunState?.lastResultState
+            label: getActionLabel(action),
+            documentWithSource,
+            modelWithSource,
+            userId: actionRunState?.userId,
+            isRunning: actionRunState?.isRunning
         };
     } else {
         const { modelField, documentField } = getModelAndDocumentFieldForLocalizedFieldPath({
             document,
             fieldPath,
             modelMap: contentSourceData.modelMap
-        });
+        }) as {
+            // list items cannot have actions, therefore we can safely omit the list item types
+            modelField: StackbitTypes.Field;
+            documentField?: ContentStoreTypes.DocumentField;
+        };
+        const csiDocumentField = documentField ? mapStoreFieldToCSIField(documentField) : undefined;
 
+        // Find an action with the provided 'actionName' in model.field.actions
         if ('actions' in modelField && Array.isArray(modelField.actions)) {
             const action = modelField.actions.find((action) => action.name === actionName);
             if (action) {
+                if (action.type === 'object') {
+                    if (!csiDocumentField) {
+                        throw new Error(`object document field not found at field path: ${fieldPath.join('.')}`);
+                    }
+                    if (modelField.type !== 'object' || csiDocumentField.type !== 'object') {
+                        // action of type 'object' cannot be defined on field other than 'object'
+                        return undefined;
+                    }
+                    return {
+                        // if configuration is updated, the new action properties will override the stored action properties
+                        ...action,
+                        extendedType: 'objectField',
+                        actionId,
+                        label: getActionLabel(action),
+                        documentWithSource,
+                        modelWithSource,
+                        documentField: csiDocumentField as StackbitTypes.DocumentObjectFieldNonLocalized,
+                        modelField: modelField as StackbitTypes.FieldObject,
+                        fieldPath,
+                        userId: actionRunState?.userId,
+                        isRunning: actionRunState?.isRunning
+                    };
+                }
                 return {
                     // if configuration is updated, the new action properties will override the stored action properties
                     ...action,
-                    type: action.type === 'object' ? 'objectField' : 'field',
+                    type: 'field',
+                    extendedType: 'field',
                     actionId,
-                    label: action.label ?? _.startCase(action.name),
-                    documentSpec,
+                    label: getActionLabel(action),
+                    documentWithSource,
+                    modelWithSource,
+                    documentField: csiDocumentField,
+                    modelField,
                     fieldPath,
-                    runningHandler: actionRunState?.runningHandler,
-                    lastResultState: actionRunState?.lastResultState
-                } as ExtendedCustomActionField | ExtendedCustomActionObjectField;
+                    userId: actionRunState?.userId,
+                    isRunning: actionRunState?.isRunning
+                };
             }
         }
 
+        // If the field is of type "model", find an action with the provided 'actionName' in model.actions
         if (modelField.type === 'model') {
-            if (!documentField || documentField.type !== 'model' || documentField.localized || documentField.isUnset) {
-                return undefined;
-            }
-            const modelName = documentField.srcModelName;
-            const model = contentSourceData.modelMap[modelName];
-            if (!model || model.type !== 'object') {
-                return undefined;
-            }
-            if (!('actions' in model && Array.isArray(model.actions))) {
-                return undefined;
-            }
-            // This is a nested model of type "object", so the action must be CustomActionObjectModel
-            const action = model.actions.find((action) => action.name === actionName);
-            if (!action) {
-                return undefined;
+            if (modelName) {
+                const objectModel = contentSourceData.modelMap[modelName];
+                if (!objectModel || objectModel.type !== 'object') {
+                    return undefined;
+                }
+                // This is a nested model of type "object", so the action must be CustomActionModelObject
+                const action = objectModel.actions?.find((action) => action.name === actionName);
+                if (!action || action.type !== 'model') {
+                    return undefined;
+                }
+                return {
+                    // if configuration is updated, the new action properties will override the stored action properties
+                    ...action,
+                    extendedType: 'modelObject',
+                    actionId,
+                    label: getActionLabel(action),
+                    documentWithSource,
+                    modelWithSource,
+                    modelField,
+                    objectModel: { ...objectModel, srcType, srcProjectId },
+                    fieldPath,
+                    userId: actionRunState?.userId,
+                    isRunning: actionRunState?.isRunning
+                };
+            } else {
+                if (!csiDocumentField || csiDocumentField.type !== 'model' || csiDocumentField.localized) {
+                    return undefined;
+                }
+                const modelName = csiDocumentField.modelName;
+                const objectModel = contentSourceData.modelMap[modelName];
+                if (!objectModel || objectModel.type !== 'object') {
+                    return undefined;
+                }
+                // This is a nested model of type "object", so the action must be CustomActionObjectModel
+                const action = objectModel.actions?.find((action) => action.name === actionName);
+                if (!action || action.type !== 'object') {
+                    return undefined;
+                }
+                return {
+                    // if configuration is updated, the new action properties will override the stored action properties
+                    ...action,
+                    type: 'object',
+                    extendedType: 'objectModel',
+                    actionId,
+                    label: getActionLabel(action),
+                    documentWithSource,
+                    modelWithSource,
+                    documentField: csiDocumentField,
+                    modelField,
+                    objectModel: { ...objectModel, srcType, srcProjectId },
+                    fieldPath,
+                    userId: actionRunState?.userId,
+                    isRunning: actionRunState?.isRunning
+                };
             }
-            return {
-                // if configuration is updated, the new action properties will override the stored action properties
-                ...action,
-                type: 'objectModel',
-                actionId,
-                label: action.label ?? _.startCase(action.name),
-                documentSpec,
-                fieldPath,
-                runningHandler: actionRunState?.runningHandler,
-                lastResultState: actionRunState?.lastResultState
-            };
         }
     }
 }
 
-function globalActionId(action: StackbitTypes.CustomActionGlobal | StackbitTypes.CustomActionBulk): string {
+function getExtendedActionFromGlobalAction({
+    action,
+    actionId,
+    actionRunState,
+    generateNewActionId
+}: {
+    action: StackbitTypes.CustomActionGlobal | StackbitTypes.CustomActionBulk | StackbitTypes.CustomActionModel;
+    actionId: string;
+    actionRunState?: CustomActionRunState;
+    generateNewActionId?: boolean;
+}): ExtendedCustomActionGlobal | ExtendedCustomActionBulk | ExtendedCustomActionModelGlobal {
+    if (action.type === 'model') {
+        return {
+            ...action,
+            extendedType: 'modelGlobal',
+            actionId: generateNewActionId && !actionRunState ? `${actionId}.${uuid().substring(0, 8)}` : actionId,
+            label: getActionLabel(action),
+            modelSpec: actionRunState?.modelSpec,
+            userId: actionRunState?.userId,
+            isRunning: actionRunState?.isRunning
+        };
+    }
+    return {
+        ...action,
+        extendedType: action.type,
+        actionId,
+        label: getActionLabel(action),
+        userId: actionRunState?.userId,
+        isRunning: actionRunState?.isRunning
+    } as ExtendedCustomActionGlobal | ExtendedCustomActionBulk;
+}
+
+function globalActionId(action: StackbitTypes.CustomActionGlobal | StackbitTypes.CustomActionBulk | StackbitTypes.CustomActionModel): string {
     return `config.actions.${action.name}`;
 }
 
@@ -750,7 +989,8 @@ function isGlobalActionId(actionId: string) {
 }
 
 function getGlobalActionNameFromId(actionId: string) {
-    return actionId.substring('config.actions.'.length);
+    const result = actionId.match(/^config\.actions\.(.+?)(?:\.([\w-]+))?$/);
+    return result ? result[1] : undefined;
 }
 
 function parseActionId(actionId: string):
@@ -758,6 +998,7 @@ function parseActionId(actionId: string):
           srcType?: string;
           srcProjectId?: string;
           srcDocumentId?: string;
+          modelName?: string;
           actionName?: string;
           fieldPath?: string[];
       }
@@ -768,3 +1009,17 @@ function parseActionId(actionId: string):
         return undefined;
     }
 }
+
+function getActionLabel(
+    action:
+        | StackbitTypes.CustomActionGlobal
+        | StackbitTypes.CustomActionBulk
+        | StackbitTypes.CustomActionModel
+        | StackbitTypes.CustomActionDocument
+        | StackbitTypes.CustomActionModelObject
+        | StackbitTypes.CustomActionObjectModel
+        | StackbitTypes.CustomActionObjectField
+        | StackbitTypes.CustomActionField
+): string {
+    return action.label ?? _.startCase(action.name);
+}