@stackbit/cms-core 0.8.4-develop.1 → 0.8.4-develop.2

package/src/utils/custom-actions.ts

@@ -1,5 +1,5 @@
 import _ from 'lodash';
-import { Config, mapModelFieldsRecursively } from '@stackbit/sdk';
+import { Config, PageModel, DataModel, FieldObjectProps, FieldSpecificProps, mapModelFieldsRecursively, ObjectModel } from '@stackbit/sdk';
 import * as StackbitTypes from '@stackbit/types';
 import { mapPromise, omitByNil } from '@stackbit/utils';
 import * as ContentStoreTypes from '../types';
@@ -13,16 +13,14 @@ import {
     APIGetCustomActionRequest,
     APIRunCustomActionRequest,
     APIRunCustomActionRequestBulk,
-    ContentStoreCustomActionMap,
-    ContentStoreCustomActionGlobal,
-    ContentStoreCustomActionBulk,
-    ContentStoreCustomActionDocument,
-    ContentStoreCustomActionObjectModel,
-    ContentStoreCustomActionField,
+    CustomActionRunStateMap,
+    ExtendedCustomActionDocument,
+    ExtendedCustomActionObjectModel,
+    ExtendedCustomActionField,
     APICustomActionGlobal,
     APICustomActionBulk,
-    ContentStoreCustomAction,
-    ContentStoreCustomActionObjectField
+    ExtendedCustomAction,
+    ExtendedCustomActionObjectField
 } from '../types';
 import { createConfigDelegate } from './config-delegate';
 import { getContentSourceActionsForSourceThunk } from './document-hooks';
@@ -59,7 +57,7 @@ export function stripModelActions({ modelMap }: { modelMap: StackbitTypes.ModelM
 
 export async function getGlobalAndBulkAPIActions({
     stackbitConfig,
-    customActionMap,
+    customActionRunStateMap,
     contentSourceDataById,
     userLogger,
     pageUrl,
@@ -68,7 +66,7 @@ export async function getGlobalAndBulkAPIActions({
     currentPageDocument
 }: {
     stackbitConfig: Config | null;
-    customActionMap: ContentStoreCustomActionMap;
+    customActionRunStateMap: CustomActionRunStateMap;
     contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
     userLogger: StackbitTypes.Logger;
     pageUrl?: string;
@@ -86,25 +84,15 @@ export async function getGlobalAndBulkAPIActions({
     });
 
     return mapPromise(stackbitConfig.actions, async (action) => {
-        const actionId = `config.actions.${action.name}`;
-        const prevStoreAction = customActionMap[actionId] as ContentStoreCustomActionGlobal | ContentStoreCustomActionBulk | undefined;
-        const storeAction: ContentStoreCustomActionGlobal | ContentStoreCustomActionBulk = {
-            // if configuration is updated, the new action properties will override the stored action properties
-            ...action,
-            actionId,
-            label: action.label ?? _.startCase(action.name),
-            runningHandler: prevStoreAction?.runningHandler,
-            lastResultState: prevStoreAction?.lastResultState
-        };
-        customActionMap[actionId] = storeAction;
-
+        const actionId = globalActionId(action);
+        const actionRunState = customActionRunStateMap[actionId];
         let state: StackbitTypes.CustomActionState | 'unknown';
 
-        if (storeAction.runningHandler) {
+        if (actionRunState?.runningHandler) {
             state = 'running';
-        } else if (storeAction.state) {
+        } else if (action.state) {
             const pageDocument = getCSIDocumentWithSourceFromDocumentSpec(currentPageDocument, configDelegate);
-            state = await storeAction.state({
+            state = await action.state({
                 actionId: actionId,
                 currentLocale: locale,
                 currentUser: user ? { name: user.name, email: user.email } : undefined,
@@ -113,189 +101,230 @@ export async function getGlobalAndBulkAPIActions({
                 ...configDelegate
             });
         } else {
-            state = storeAction.lastResultState ?? 'enabled';
+            state = actionRunState?.lastResultState ?? 'enabled';
         }
 
         return omitByNil({
+            type: action.type,
             actionId: actionId,
-            type: storeAction.type,
-            name: storeAction.name,
-            label: storeAction.label,
-            icon: storeAction.icon,
+            name: action.name,
+            label: action.label ?? _.startCase(action.name),
+            icon: action.icon,
             state: state,
-            inputFields: storeAction.inputFields
+            inputFields: action.inputFields
         });
     });
 }
 
-export function convertDocumentActionToAPICustomDocumentAction({
-    action,
-    customActionMap,
-    csiDocument
+export function getDocumentActionsThunk({
+    csiDocument,
+    model,
+    srcType,
+    srcProjectId,
+    customActionRunStateMap
 }: {
-    action: StackbitTypes.CustomActionDocument;
-    customActionMap: ContentStoreCustomActionMap;
-    csiDocument: StackbitTypes.DocumentWithSource;
-}): APICustomActionDocument {
-    const actionId = `${csiDocument.srcType}:${csiDocument.srcProjectId}:${csiDocument.id}:${action.name}`;
-
-    const prevStoreAction = customActionMap[actionId] as ContentStoreCustomActionDocument | undefined;
-    const storeAction: ContentStoreCustomActionDocument = {
-        // if configuration is updated, the new action properties will override the stored action properties
-        ...action,
-        type: 'document',
-        actionId,
-        label: action.label ?? _.startCase(action.name),
-        runningHandler: prevStoreAction?.runningHandler,
-        lastResultState: prevStoreAction?.lastResultState,
-        documentSpec: {
-            srcType: csiDocument.srcType,
-            srcProjectId: csiDocument.srcProjectId,
-            srcDocumentId: csiDocument.id
-        }
-    };
-    customActionMap[actionId] = storeAction;
-
-    let state: StackbitTypes.CustomActionState | 'unknown';
-    let needsResolving = false;
-    if (storeAction?.runningHandler) {
-        state = 'running';
-    } else if (action.state) {
-        state = 'unknown';
-        needsResolving = true;
-    } else {
-        state = storeAction?.lastResultState ?? 'enabled';
+    csiDocument: StackbitTypes.Document;
+    model: PageModel | DataModel;
+    srcType: string;
+    srcProjectId: string;
+    customActionRunStateMap: ContentStoreTypes.CustomActionRunStateMap;
+}): () => APICustomActionDocument[] | undefined {
+    if (!('actions' in model) || !Array.isArray(model.actions)) {
+        return () => undefined;
     }
 
-    return omitByNil({
-        actionId: actionId,
-        type: 'document',
-        name: storeAction.name,
-        label: storeAction.label,
-        icon: storeAction.icon,
-        state: state,
-        inputFields: storeAction.inputFields,
-        needsResolving: needsResolving
+    const extendedDocumentActions = model.actions.map((action): ExtendedCustomActionDocument => {
+        const documentSpec = {
+            srcType: srcType,
+            srcProjectId: srcProjectId,
+            srcDocumentId: csiDocument.id
+        };
+        return {
+            // if configuration is updated, the new action properties will override the stored action properties
+            ...action,
+            type: 'document',
+            actionId: documentActionId({ ...documentSpec, actionName: action.name }),
+            label: action.label ?? _.startCase(action.name),
+            documentSpec: documentSpec
+        };
     });
+
+    return () =>
+        extendedDocumentActions.map((extendedAction) => {
+            return omitByNil({
+                type: 'document',
+                actionId: extendedAction.actionId,
+                name: extendedAction.name,
+                label: extendedAction.label,
+                icon: extendedAction.icon,
+                inputFields: extendedAction.inputFields,
+                ...getAPIActionState(extendedAction, customActionRunStateMap)
+            });
+        });
 }
 
-export function convertObjectModelActionToAPICustomObjectAction({
-    action,
-    customActionMap,
+export function getObjectModelActionsThunk({
+    model,
     csiParentDocument,
+    srcType,
+    srcProjectId,
+    customActionRunStateMap,
     fieldPath
 }: {
-    action: StackbitTypes.CustomActionObjectModel;
-    customActionMap: ContentStoreCustomActionMap;
-    csiParentDocument: StackbitTypes.DocumentWithSource;
+    model: ObjectModel;
+    csiParentDocument: StackbitTypes.Document;
+    srcType: string;
+    srcProjectId: string;
+    customActionRunStateMap: ContentStoreTypes.CustomActionRunStateMap;
     fieldPath: (string | number)[];
-}): APICustomActionObject {
-    const actionId = `${csiParentDocument.srcType}:${csiParentDocument.srcProjectId}:${csiParentDocument.id}:${fieldPath.join('.')}:${action.name}`;
-
-    const prevStoreAction = customActionMap[actionId] as ContentStoreCustomActionObjectModel | undefined;
-    const storeAction: ContentStoreCustomActionObjectModel = {
-        // if configuration is updated, the new action properties will override the stored action properties
-        ...action,
-        type: 'objectModel',
-        actionId,
-        label: action.label ?? _.startCase(action.name),
-        runningHandler: prevStoreAction?.runningHandler,
-        lastResultState: prevStoreAction?.lastResultState,
-        documentSpec: {
-            srcType: csiParentDocument.srcType,
-            srcProjectId: csiParentDocument.srcProjectId,
-            srcDocumentId: csiParentDocument.id
-        },
-        fieldPath
-    };
-    customActionMap[actionId] = storeAction;
-
-    let state: StackbitTypes.CustomActionState | 'unknown';
-    let needsResolving = false;
-    if (storeAction?.runningHandler) {
-        state = 'running';
-    } else if (action.state) {
-        state = 'unknown';
-        needsResolving = true;
-    } else {
-        state = storeAction?.lastResultState ?? 'enabled';
+}): () => ContentStoreTypes.APICustomActionObject[] | undefined {
+    if (!('actions' in model) || !Array.isArray(model.actions)) {
+        return () => undefined;
     }
 
-    return omitByNil({
-        actionId: actionId,
-        type: 'object',
-        name: storeAction.name,
-        label: storeAction.label,
-        icon: storeAction.icon,
-        state: state,
-        inputFields: storeAction.inputFields,
-        needsResolving: needsResolving
+    const extendedObjectModelActions = model.actions.map((action): ExtendedCustomActionObjectModel => {
+        const documentSpec = {
+            srcType: srcType,
+            srcProjectId: srcProjectId,
+            srcDocumentId: csiParentDocument.id
+        };
+        return {
+            // if configuration is updated, the new action properties will override the stored action properties
+            ...action,
+            type: 'objectModel',
+            actionId: fieldPathActionId({ ...documentSpec, fieldPath, actionName: action.name }),
+            label: action.label ?? _.startCase(action.name),
+            documentSpec: documentSpec,
+            fieldPath
+        };
     });
+
+    return () =>
+        extendedObjectModelActions.map((extendedAction) => {
+            return omitByNil({
+                type: 'object',
+                actionId: extendedAction.actionId,
+                name: extendedAction.name,
+                label: extendedAction.label,
+                icon: extendedAction.icon,
+                inputFields: extendedAction.inputFields,
+                ...getAPIActionState(extendedAction, customActionRunStateMap)
+            });
+        });
 }
 
-export function convertFieldActionToAPICustomAction<T extends StackbitTypes.CustomActionField | StackbitTypes.CustomActionObjectField>({
-    action,
-    customActionMap,
+export function getObjectFieldActionsThunk({
+    modelField,
     csiParentDocument,
+    srcType,
+    srcProjectId,
+    customActionRunStateMap,
     fieldPath
 }: {
-    action: T;
-    customActionMap: ContentStoreCustomActionMap;
-    csiParentDocument: StackbitTypes.DocumentWithSource;
+    modelField: FieldObjectProps;
+    csiParentDocument: StackbitTypes.Document;
+    srcType: string;
+    srcProjectId: string;
+    customActionRunStateMap: ContentStoreTypes.CustomActionRunStateMap;
     fieldPath: (string | number)[];
-}): T extends StackbitTypes.CustomActionField ? APICustomActionField : APICustomActionObject {
-    const actionId = `${csiParentDocument.srcType}:${csiParentDocument.srcProjectId}:${csiParentDocument.id}:${fieldPath.join('.')}:${action.name}`;
-
-    const prevStoreAction = customActionMap[actionId] as ContentStoreCustomActionField | ContentStoreCustomActionObjectField | undefined;
-    const storeAction = {
-        // if configuration is updated, the new action properties will override the stored action properties
-        ...action,
-        type: action.type === 'object' ? 'objectField' : 'field',
-        actionId,
-        label: action.label ?? _.startCase(action.name),
-        runningHandler: prevStoreAction?.runningHandler,
-        lastResultState: prevStoreAction?.lastResultState,
-        documentSpec: {
-            srcType: csiParentDocument.srcType,
-            srcProjectId: csiParentDocument.srcProjectId,
+}): () => APICustomActionObject[] | undefined {
+    if (!('actions' in modelField) || !Array.isArray(modelField.actions)) {
+        return () => undefined;
+    }
+    const objectFieldActions = modelField.actions.filter((action): action is StackbitTypes.CustomActionObjectField => action.type === 'object');
+
+    const extendedObjectFieldActions = objectFieldActions.map((action): ExtendedCustomActionObjectField => {
+        const documentSpec = {
+            srcType: srcType,
+            srcProjectId: srcProjectId,
             srcDocumentId: csiParentDocument.id
-        },
-        fieldPath
-    } as ContentStoreCustomActionField | ContentStoreCustomActionObjectField;
-    customActionMap[actionId] = storeAction;
+        };
+        return {
+            // if configuration is updated, the new action properties will override the stored action properties
+            ...action,
+            type: 'objectField',
+            actionId: fieldPathActionId({ ...documentSpec, fieldPath, actionName: action.name }),
+            label: action.label ?? _.startCase(action.name),
+            documentSpec: documentSpec,
+            fieldPath
+        };
+    });
 
-    let state: StackbitTypes.CustomActionState | 'unknown';
-    let needsResolving = false;
-    if (storeAction?.runningHandler) {
-        state = 'running';
-    } else if (action.state) {
-        state = 'unknown';
-        needsResolving = true;
-    } else {
-        state = storeAction?.lastResultState ?? 'enabled';
+    return () =>
+        extendedObjectFieldActions.map((extendedAction) => {
+            return omitByNil({
+                type: 'object',
+                actionId: extendedAction.actionId,
+                name: extendedAction.name,
+                label: extendedAction.label,
+                icon: extendedAction.icon,
+                inputFields: extendedAction.inputFields,
+                ...getAPIActionState(extendedAction, customActionRunStateMap)
+            });
+        });
+}
+
+export function getFieldActions({
+    modelField,
+    csiParentDocument,
+    srcType,
+    srcProjectId,
+    customActionRunStateMap,
+    fieldPath
+}: {
+    modelField: FieldSpecificProps;
+    csiParentDocument: StackbitTypes.Document;
+    srcType: string;
+    srcProjectId: string;
+    customActionRunStateMap: ContentStoreTypes.CustomActionRunStateMap;
+    fieldPath: (string | number)[];
+}): APICustomActionField[] | undefined {
+    if (!('actions' in modelField) || !Array.isArray(modelField.actions)) {
+        return undefined;
     }
+    const fieldActions = modelField.actions.filter((action): action is StackbitTypes.CustomActionField => action.type !== 'object');
+
+    const extendedFieldActions = fieldActions.map((action): ExtendedCustomActionField => {
+        const documentSpec = {
+            srcType: srcType,
+            srcProjectId: srcProjectId,
+            srcDocumentId: csiParentDocument.id
+        };
+        return {
+            // if configuration is updated, the new action properties will override the stored action properties
+            ...action,
+            type: 'field',
+            actionId: fieldPathActionId({ ...documentSpec, fieldPath, actionName: action.name }),
+            label: action.label ?? _.startCase(action.name),
+            documentSpec: documentSpec,
+            fieldPath
+        };
+    });
 
-    return omitByNil({
-        actionId: actionId,
-        type: action.type ?? 'field',
-        name: storeAction.name,
-        label: storeAction.label,
-        icon: storeAction.icon,
-        state: state,
-        inputFields: storeAction.inputFields,
-        needsResolving: needsResolving
-    }) as T extends StackbitTypes.CustomActionField ? APICustomActionField : APICustomActionObject;
+    return extendedFieldActions.map((extendedAction) => {
+        return omitByNil({
+            type: 'field',
+            actionId: extendedAction.actionId,
+            name: extendedAction.name,
+            label: extendedAction.label,
+            icon: extendedAction.icon,
+            inputFields: extendedAction.inputFields,
+            ...getAPIActionState(extendedAction, customActionRunStateMap)
+        });
+    });
 }
 
 export async function resolveCustomActionsById({
     getActionRequest,
-    customActionMap,
+    customActionRunStateMap,
     contentSourceDataById,
+    stackbitConfig,
     userLogger
 }: {
     getActionRequest: APIGetCustomActionRequest;
-    customActionMap: ContentStoreCustomActionMap;
+    customActionRunStateMap: CustomActionRunStateMap;
     contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
+    stackbitConfig: Config | null;
     userLogger: StackbitTypes.Logger;
 }): Promise<APICustomAction[]> {
     const result: APICustomAction[] = [];
@@ -307,17 +336,22 @@ export async function resolveCustomActionsById({
     });
 
     for (const actionId of customActionIds) {
-        const storeAction = customActionMap[actionId];
-        if (!storeAction) {
-            userLogger.debug(`getCustomActionsById: custom action not found, id: '${actionId}'`);
+        const extendedAction = findCustomActionById({
+            actionId,
+            customActionRunStateMap,
+            contentSourceDataById,
+            stackbitConfig
+        });
+        if (!extendedAction) {
+            userLogger.debug(`custom action with id: '${actionId}' was not found`);
             continue;
         }
 
         try {
             let state: StackbitTypes.CustomActionState;
-            if (storeAction.runningHandler) {
+            if (extendedAction.runningHandler) {
                 state = 'running';
-            } else if (storeAction.state) {
+            } else if (extendedAction.state) {
                 const pageDocument = getCSIDocumentWithSourceFromDocumentSpec(currentPageDocument, configDelegate);
                 const commonStateOptions: StackbitTypes.CustomActionStateCommonOptions = {
                     actionId: actionId,
@@ -332,61 +366,61 @@ export async function resolveCustomActionsById({
                     currentPageDocument: pageDocument,
                     ...configDelegate
                 };
-                if (storeAction.type === 'global' || storeAction.type === 'bulk') {
-                    state = await storeAction.state(commonStateOptions);
-                } else if (storeAction.type === 'document') {
+                if (extendedAction.type === 'global' || extendedAction.type === 'bulk') {
+                    state = await extendedAction.state(commonStateOptions);
+                } else if (extendedAction.type === 'document') {
                     const { document, model } = getCSIDocumentAndModelWithSourceFromDocumentSpec({
-                        documentSpec: storeAction.documentSpec,
+                        documentSpec: extendedAction.documentSpec,
                         contentSourceDataById
                     });
-                    state = await storeAction.state({
+                    state = await extendedAction.state({
                         ...commonStateOptions,
                         document: document,
                         model: model
                     });
-                } else if (storeAction.type === 'objectModel') {
+                } else if (extendedAction.type === 'objectModel') {
                     const stateObjectParams = getHandlerParamsForObjectModelAction({
-                        storeAction,
+                        extendedAction,
                         contentSourceDataById
                     });
-                    state = await storeAction.state({
+                    state = await extendedAction.state({
                         ...commonStateOptions,
                         ...stateObjectParams
                     });
-                } else if (storeAction.type === 'objectField') {
+                } else if (extendedAction.type === 'objectField') {
                     const stateObjectParams = getHandlerParamsForObjectFieldAction({
-                        storeAction,
+                        extendedAction,
                         contentSourceDataById
                     });
-                    state = await storeAction.state({
+                    state = await extendedAction.state({
                         ...commonStateOptions,
                         ...stateObjectParams
                     });
-                } else if (storeAction.type === 'field') {
+                } else if (extendedAction.type === 'field') {
                     const stateFieldParams = getHandlerParamsForFieldAction({
-                        storeAction,
+                        extendedAction,
                         contentSourceDataById
                     });
-                    state = await storeAction.state({
+                    state = await extendedAction.state({
                         ...commonStateOptions,
                         ...stateFieldParams
                     });
                 } else {
-                    const _exhaustiveCheck: never = storeAction;
+                    const _exhaustiveCheck: never = extendedAction;
                     continue;
                 }
             } else {
-                state = storeAction?.lastResultState ?? 'enabled';
+                state = extendedAction.lastResultState ?? 'enabled';
             }
             result.push(
                 omitByNil({
                     actionId: actionId,
-                    type: storeActionTypeToAPIActionType(storeAction.type),
-                    name: storeAction.name,
-                    label: storeAction.label,
-                    icon: storeAction.icon,
+                    type: storeActionTypeToAPIActionType(extendedAction.type),
+                    name: extendedAction.name,
+                    label: extendedAction.label,
+                    icon: extendedAction.icon,
                     state: state,
-                    inputFields: storeAction.inputFields
+                    inputFields: extendedAction.inputFields
                 })
             );
         } catch (error: any) {
@@ -399,38 +433,45 @@ export async function resolveCustomActionsById({
 
 export function runCustomAction({
     runActionRequest,
-    customActionMap,
+    customActionRunStateMap,
     contentSourceDataById,
-    userLogger,
-    stackbitConfig
+    stackbitConfig,
+    userLogger
 }: {
     runActionRequest: APIRunCustomActionRequest;
-    customActionMap: ContentStoreCustomActionMap;
+    customActionRunStateMap: CustomActionRunStateMap;
     contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
-    userLogger: StackbitTypes.Logger;
     stackbitConfig: Config | null;
+    userLogger: StackbitTypes.Logger;
 }): Promise<CustomActionStateChange> {
-    const storeAction = customActionMap[runActionRequest.actionId];
-    if (!storeAction) {
+    const extendedAction = findCustomActionById({
+        actionId: runActionRequest.actionId,
+        customActionRunStateMap,
+        contentSourceDataById,
+        stackbitConfig
+    });
+    if (!extendedAction) {
         throw new Error(`Error running action: action not found, action name: '${runActionRequest.actionName}' action ID: '${runActionRequest.actionId}'.`);
     }
-    const prevResultState = storeAction.lastResultState;
-    if (storeAction.lastResultState && storeAction.lastResultState !== 'enabled') {
+    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}'.`
         );
     }
 
     try {
-        const actionLogger = userLogger.createLogger({ label: `action:${storeAction.name}` });
+        const actionLogger = userLogger.createLogger({ label: `action:${extendedAction.name}` });
         const configDelegate = createConfigDelegate({ contentSourceDataById: contentSourceDataById, logger: actionLogger });
         const currentPageDocument = getCSIDocumentWithSourceFromDocumentSpec(runActionRequest.currentPageDocument, configDelegate);
 
-        storeAction.runningHandler = true;
-        storeAction.lastResultState = 'running';
+        customActionRunStateMap[runActionRequest.actionId] = {
+            runningHandler: true,
+            lastResultState: 'running'
+        };
 
         const commonRunOptions: StackbitTypes.CustomActionRunCommonOptions = {
-            actionId: storeAction.actionId,
+            actionId: extendedAction.actionId,
             inputData: runActionRequest.inputData,
             currentLocale: runActionRequest.locale,
             currentUser: runActionRequest.user,
@@ -448,9 +489,9 @@ export function runCustomAction({
 
         let promise;
 
-        if (storeAction.type === 'global') {
-            promise = storeAction.run(commonRunOptions);
-        } else if (storeAction.type === 'bulk') {
+        if (extendedAction.type === 'global') {
+            promise = extendedAction.run(commonRunOptions);
+        } else if (extendedAction.type === 'bulk') {
             const documents = (runActionRequest as APIRunCustomActionRequestBulk).documents.map((documentSpec) => {
                 const { document } = getCSIDocumentAndModelWithSourceFromDocumentSpec({
                     documentSpec,
@@ -458,74 +499,76 @@ export function runCustomAction({
                 });
                 return document;
             });
-            promise = storeAction.run({
+            promise = extendedAction.run({
                 ...commonRunOptions,
                 documents
             });
-        } else if (storeAction.type === 'document') {
+        } else if (extendedAction.type === 'document') {
             const { document, model } = getCSIDocumentAndModelWithSourceFromDocumentSpec({
-                documentSpec: storeAction.documentSpec,
+                documentSpec: extendedAction.documentSpec,
                 contentSourceDataById
             });
-            promise = storeAction.run({
+            promise = extendedAction.run({
                 ...commonRunOptions,
                 document,
                 model,
                 contentSourceActions: commonRunOptions.getContentSourceActionsForSource({
-                    srcType: storeAction.documentSpec.srcType,
-                    srcProjectId: storeAction.documentSpec.srcProjectId
+                    srcType: extendedAction.documentSpec.srcType,
+                    srcProjectId: extendedAction.documentSpec.srcProjectId
                 })!
             });
-        } else if (storeAction.type === 'objectModel') {
+        } else if (extendedAction.type === 'objectModel') {
             const handlerObjectParams = getHandlerParamsForObjectModelAction({
-                storeAction,
+                extendedAction,
                 contentSourceDataById
             });
-            promise = storeAction.run({
+            promise = extendedAction.run({
                 ...commonRunOptions,
                 ...handlerObjectParams,
                 contentSourceActions: commonRunOptions.getContentSourceActionsForSource({
-                    srcType: storeAction.documentSpec.srcType,
-                    srcProjectId: storeAction.documentSpec.srcProjectId
+                    srcType: extendedAction.documentSpec.srcType,
+                    srcProjectId: extendedAction.documentSpec.srcProjectId
                 })!
             });
-        } else if (storeAction.type === 'objectField') {
+        } else if (extendedAction.type === 'objectField') {
             const handlerObjectParams = getHandlerParamsForObjectFieldAction({
-                storeAction,
+                extendedAction,
                 contentSourceDataById
             });
-            promise = storeAction.run({
+            promise = extendedAction.run({
                 ...commonRunOptions,
                 ...handlerObjectParams,
                 contentSourceActions: commonRunOptions.getContentSourceActionsForSource({
-                    srcType: storeAction.documentSpec.srcType,
-                    srcProjectId: storeAction.documentSpec.srcProjectId
+                    srcType: extendedAction.documentSpec.srcType,
+                    srcProjectId: extendedAction.documentSpec.srcProjectId
                 })!
             });
-        } else if (storeAction.type === 'field') {
-            const handlerFieldParams = getHandlerParamsForFieldAction({ storeAction, contentSourceDataById });
-            promise = storeAction.run({
+        } else if (extendedAction.type === 'field') {
+            const handlerFieldParams = getHandlerParamsForFieldAction({ extendedAction, contentSourceDataById });
+            promise = extendedAction.run({
                 ...commonRunOptions,
                 ...handlerFieldParams,
                 contentSourceActions: commonRunOptions.getContentSourceActionsForSource({
-                    srcType: storeAction.documentSpec.srcType,
-                    srcProjectId: storeAction.documentSpec.srcProjectId
+                    srcType: extendedAction.documentSpec.srcType,
+                    srcProjectId: extendedAction.documentSpec.srcProjectId
                 })!
             });
         } else {
-            throw new Error(`action type ${(storeAction as any).type} not supported`);
+            throw new Error(`action type ${(extendedAction as any).type} not supported`);
         }
 
         return promise
             .then((actionResult) => {
-                storeAction.runningHandler = false;
-                storeAction.lastResultState = actionResult?.state;
-                userLogger.debug(`Action completed: ${storeAction.actionId}`);
+                customActionRunStateMap[runActionRequest.actionId] = {
+                    runningHandler: false,
+                    lastResultState: actionResult?.state
+                };
+                userLogger.debug(`Action completed: ${extendedAction.actionId}`);
                 return Promise.resolve(
                     omitByNil({
-                        actionId: storeAction.actionId,
-                        actionName: storeAction.name,
-                        actionType: storeActionTypeToAPIActionType(storeAction.type),
+                        actionId: extendedAction.actionId,
+                        actionName: extendedAction.name,
+                        actionType: storeActionTypeToAPIActionType(extendedAction.type),
                         // TODO: resolve the state if state function is defined
                         state: actionResult?.state ?? 'enabled',
                         success: actionResult?.success,
@@ -534,28 +577,32 @@ export function runCustomAction({
                 );
             })
             .catch((error: any) => {
-                storeAction.runningHandler = false;
-                storeAction.lastResultState = prevResultState;
+                customActionRunStateMap[runActionRequest.actionId] = {
+                    runningHandler: false,
+                    lastResultState: prevResultState
+                };
                 userLogger.debug(`Error running action: ${error.message}`);
                 return Promise.resolve({
-                    actionId: storeAction.actionId,
-                    actionName: storeAction.name,
-                    actionType: storeActionTypeToAPIActionType(storeAction.type),
+                    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}`
                 });
             });
     } catch (error: any) {
-        if (storeAction) {
-            storeAction.runningHandler = false;
-            storeAction.lastResultState = prevResultState;
+        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: storeAction?.name ?? runActionRequest.actionName,
-            actionType: storeActionTypeToAPIActionType(storeAction?.type) ?? runActionRequest.actionType,
+            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}`
@@ -576,24 +623,46 @@ function getCSIDocumentWithSourceFromDocumentSpec(
         : undefined;
 }
 
+function getAPIActionState(
+    extendedAction: ExtendedCustomAction,
+    customActionRunStateMap: CustomActionRunStateMap
+): {
+    state: StackbitTypes.CustomActionState | 'unknown';
+    needsResolving: boolean;
+} {
+    const actionId = extendedAction.actionId;
+    const actionRunState = customActionRunStateMap[actionId];
+    let state: StackbitTypes.CustomActionState | 'unknown';
+    let needsResolving = false;
+    if (actionRunState?.runningHandler) {
+        state = 'running';
+    } else if (extendedAction.state) {
+        state = 'unknown';
+        needsResolving = true;
+    } else {
+        state = actionRunState?.lastResultState ?? 'enabled';
+    }
+    return { state, needsResolving };
+}
+
 function getHandlerParamsForObjectModelAction({
-    storeAction,
+    extendedAction,
     contentSourceDataById
 }: {
-    storeAction: Pick<ContentStoreCustomActionObjectModel, 'documentSpec' | 'fieldPath'>;
+    extendedAction: Pick<ExtendedCustomActionObjectModel, 'documentSpec' | 'fieldPath'>;
     contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
 }): StackbitTypes.CustomActionObjectModelStateParams {
     const fieldActionCommonParams = getHandlerParamsForFieldAction({
-        storeAction,
+        extendedAction,
         contentSourceDataById
     });
 
     if (!fieldActionCommonParams.documentField) {
-        throw new Error(`object document field not found at field path: ${storeAction.fieldPath.join('.')}`);
+        throw new Error(`object document field not found at field path: ${extendedAction.fieldPath.join('.')}`);
     }
 
     const documentField = fieldActionCommonParams.documentField as StackbitTypes.DocumentModelFieldNonLocalized;
-    const documentSpec = storeAction.documentSpec;
+    const documentSpec = extendedAction.documentSpec;
     const contentSourceData = getContentSourceDataByTypeAndProjectIdOrThrow(documentSpec.srcType, documentSpec.srcProjectId, contentSourceDataById);
     const objectModel = contentSourceData.modelMap[documentField.modelName];
     if (!objectModel || objectModel.type !== 'object') {
@@ -613,19 +682,19 @@ function getHandlerParamsForObjectModelAction({
 }
 
 function getHandlerParamsForObjectFieldAction({
-    storeAction,
+    extendedAction,
     contentSourceDataById
 }: {
-    storeAction: Pick<ContentStoreCustomActionObjectField, 'documentSpec' | 'fieldPath'>;
+    extendedAction: Pick<ExtendedCustomActionObjectField, 'documentSpec' | 'fieldPath'>;
     contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
 }): StackbitTypes.CustomActionObjectFieldStateParams {
     const fieldActionCommonParams = getHandlerParamsForFieldAction({
-        storeAction,
+        extendedAction,
         contentSourceDataById
     });
 
     if (!fieldActionCommonParams.documentField) {
-        throw new Error(`object document field not found at field path: ${storeAction.fieldPath.join('.')}`);
+        throw new Error(`object document field not found at field path: ${extendedAction.fieldPath.join('.')}`);
     }
 
     return {
@@ -636,13 +705,13 @@ function getHandlerParamsForObjectFieldAction({
 }
 
 function getHandlerParamsForFieldAction({
-    storeAction,
+    extendedAction,
     contentSourceDataById
 }: {
-    storeAction: Pick<ContentStoreCustomActionField, 'documentSpec' | 'fieldPath'>;
+    extendedAction: Pick<ExtendedCustomActionField, 'documentSpec' | 'fieldPath'>;
     contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
 }): StackbitTypes.CustomActionFieldStateParams {
-    const documentSpec = storeAction.documentSpec;
+    const documentSpec = extendedAction.documentSpec;
     const contentSourceData = getContentSourceDataByTypeAndProjectIdOrThrow(documentSpec.srcType, documentSpec.srcProjectId, contentSourceDataById);
     const document = contentSourceData.documentMap[documentSpec.srcDocumentId];
     const csiDocument = contentSourceData.csiDocumentMap[documentSpec.srcDocumentId];
@@ -663,7 +732,7 @@ function getHandlerParamsForFieldAction({
     const { modelField, documentField } = getModelAndDocumentFieldForLocalizedFieldPath({
         document,
         model,
-        fieldPath: storeAction.fieldPath,
+        fieldPath: extendedAction.fieldPath,
         modelMap: contentSourceData.modelMap
     }) as {
         // list items cannot have actions, therefore we can safely reduce the type to non list item fields
@@ -682,7 +751,7 @@ function getHandlerParamsForFieldAction({
         },
         documentField: csiDocumentField,
         modelField: modelField,
-        fieldPath: storeAction.fieldPath
+        fieldPath: extendedAction.fieldPath
     };
 }
 
@@ -722,9 +791,191 @@ function getCSIDocumentAndModelWithSourceFromDocumentSpec({
     };
 }
 
-function storeActionTypeToAPIActionType(storeActionType: ContentStoreCustomAction['type']): APICustomAction['type'] {
+function storeActionTypeToAPIActionType(storeActionType: ExtendedCustomAction['type']): APICustomAction['type'] {
     if (storeActionType === 'objectModel' || storeActionType === 'objectField') {
         return 'object';
     }
     return storeActionType;
 }
+
+function findCustomActionById({
+    actionId,
+    customActionRunStateMap,
+    contentSourceDataById,
+    stackbitConfig
+}: {
+    actionId: string;
+    customActionRunStateMap: CustomActionRunStateMap;
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
+    stackbitConfig: Config | null;
+}): ExtendedCustomAction | undefined {
+    const actionRunState = customActionRunStateMap[actionId];
+    if (isGlobalActionId(actionId)) {
+        if (!stackbitConfig || !Array.isArray(stackbitConfig.actions)) {
+            return undefined;
+        }
+        const actionName = getGlobalActionNameFromId(actionId);
+        const action = stackbitConfig.actions.find((action) => action.name === actionName);
+        if (!action) {
+            return undefined;
+        }
+        return {
+            ...action,
+            actionId,
+            label: action.label ?? _.startCase(action.name),
+            runningHandler: actionRunState?.runningHandler,
+            lastResultState: actionRunState?.lastResultState
+        };
+    }
+    const { srcType, srcProjectId, srcDocumentId, actionName, fieldPath } = parseActionId(actionId) ?? {};
+    if (!srcType || !srcProjectId || !srcDocumentId || !actionName) {
+        return undefined;
+    }
+    const documentSpec: APICustomActionDocumentSpecifier = { srcType, srcProjectId, srcDocumentId };
+    const contentSourceData = getContentSourceDataByTypeAndProjectIdOrThrow(srcType, srcProjectId, contentSourceDataById);
+    const document = contentSourceData.documentMap[srcDocumentId];
+    if (!document) {
+        return undefined;
+    }
+    const modelName = document.srcModelName;
+    const model = contentSourceData.modelMap[modelName];
+    // The model of a document is always 'page' or 'data',
+    // this condition helps TS to infer the right type of model.actions
+    if (!model || (model.type !== 'page' && model.type !== 'data')) {
+        return undefined;
+    }
+    if (!('actions' in model) || !Array.isArray(model.actions)) {
+        return undefined;
+    }
+    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'
+        const action = model.actions.find((action) => action.name === actionName);
+        if (!action) {
+            return undefined;
+        }
+        return {
+            // if configuration is updated, the new action properties will override the stored action properties
+            ...action,
+            type: 'document',
+            actionId,
+            label: action.label ?? _.startCase(action.name),
+            documentSpec,
+            runningHandler: actionRunState?.runningHandler,
+            lastResultState: actionRunState?.lastResultState
+        };
+    } else {
+        const { modelField, documentField } = getModelAndDocumentFieldForLocalizedFieldPath({
+            document,
+            model,
+            fieldPath,
+            modelMap: contentSourceData.modelMap
+        });
+
+        if ('actions' in modelField && Array.isArray(modelField.actions)) {
+            const action = modelField.actions.find((action) => action.name === actionName);
+            if (action) {
+                return {
+                    // if configuration is updated, the new action properties will override the stored action properties
+                    ...action,
+                    type: action.type === 'object' ? 'objectField' : 'field',
+                    actionId,
+                    label: action.label ?? _.startCase(action.name),
+                    documentSpec,
+                    fieldPath,
+                    runningHandler: actionRunState?.runningHandler,
+                    lastResultState: actionRunState?.lastResultState
+                } as ExtendedCustomActionField | ExtendedCustomActionObjectField;
+            }
+        }
+
+        if (modelField.type === 'model') {
+            if (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;
+            }
+            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 {
+    return `config.actions.${action.name}`;
+}
+
+function isGlobalActionId(actionId: string) {
+    return actionId.startsWith('config.actions.');
+}
+
+function getGlobalActionNameFromId(actionId: string) {
+    return actionId.substring('config.actions.'.length);
+}
+
+function documentActionId({ srcType, srcProjectId, srcDocumentId, actionName }: APICustomActionDocumentSpecifier & { actionName: string }): string {
+    return `${srcType}:${srcProjectId}:${srcDocumentId}:${actionName}`;
+}
+
+function fieldPathActionId({
+    srcType,
+    srcProjectId,
+    srcDocumentId,
+    fieldPath,
+    actionName
+}: APICustomActionDocumentSpecifier & { fieldPath: (string | number)[]; actionName: string }): string {
+    return `${srcType}:${srcProjectId}:${srcDocumentId}:${fieldPath.join('.')}:${actionName}`;
+}
+
+function parseActionId(actionId: string):
+    | {
+          srcType?: string;
+          srcProjectId?: string;
+          srcDocumentId?: string;
+          actionName?: string;
+          fieldPath?: string[];
+      }
+    | undefined {
+    const parts = actionId.split(':');
+    if (parts.length < 4 || parts.length > 5) {
+        return undefined;
+    }
+    const srcType = parts[0];
+    const srcProjectId = parts[1];
+    const srcDocumentId = parts[2];
+    let fieldPath: string[] | undefined;
+    let actionName: string | undefined;
+    if (parts.length === 5) {
+        fieldPath = parts[3]?.split('.');
+        actionName = parts[4];
+    } else {
+        actionName = parts[3];
+    }
+    return {
+        srcType,
+        srcProjectId,
+        srcDocumentId,
+        actionName,
+        fieldPath
+    };
+}