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

package/src/types/custom-actions.ts

@@ -10,36 +10,42 @@ import {
 } from '@stackbit/types';
 import { User } from './index';
 
-export type ContentStoreCustomActionMap = Record<string, ContentStoreCustomAction>;
-
-export type ContentStoreCustomAction =
-    | ContentStoreCustomActionGlobal
-    | ContentStoreCustomActionBulk
-    | ContentStoreCustomActionDocument
-    | ContentStoreCustomActionObjectModel
-    | ContentStoreCustomActionObjectField
-    | ContentStoreCustomActionField;
-
-export type ContentStoreCustomActionGlobal = CustomActionGlobal & ContentStoreCustomActionCommonProps;
-export type ContentStoreCustomActionBulk = CustomActionBulk & ContentStoreCustomActionCommonProps;
-export type ContentStoreCustomActionDocument = CustomActionDocument &
+export type CustomActionRunStateMap = Record<string, CustomActionRunState>;
+export type CustomActionRunState = {
+    // specifies if the action is current running in this container instance
+    runningHandler?: boolean;
+    // the action state returned by the recent 'run' invocation
+    lastResultState?: CustomActionState;
+};
+
+export type ExtendedCustomAction =
+    | ExtendedCustomActionGlobal
+    | ExtendedCustomActionBulk
+    | ExtendedCustomActionDocument
+    | ExtendedCustomActionObjectModel
+    | ExtendedCustomActionObjectField
+    | ExtendedCustomActionField;
+
+export type ExtendedCustomActionGlobal = CustomActionGlobal & ContentStoreCustomActionCommonProps;
+export type ExtendedCustomActionBulk = CustomActionBulk & ContentStoreCustomActionCommonProps;
+export type ExtendedCustomActionDocument = CustomActionDocument &
     ContentStoreCustomActionCommonProps & {
         type: 'document';
         documentSpec: APICustomActionDocumentSpecifier;
     };
-export type ContentStoreCustomActionObjectModel = CustomActionObjectModel &
+export type ExtendedCustomActionObjectModel = CustomActionObjectModel &
     ContentStoreCustomActionCommonProps & {
         type: 'objectModel';
         documentSpec: APICustomActionDocumentSpecifier;
         fieldPath: (string | number)[];
     };
-export type ContentStoreCustomActionObjectField = Omit<CustomActionObjectField, 'type'> &
+export type ExtendedCustomActionObjectField = Omit<CustomActionObjectField, 'type'> &
     ContentStoreCustomActionCommonProps & {
         type: 'objectField';
         documentSpec: APICustomActionDocumentSpecifier;
         fieldPath: (string | number)[];
     };
-export type ContentStoreCustomActionField = CustomActionField &
+export type ExtendedCustomActionField = CustomActionField &
     ContentStoreCustomActionCommonProps & {
         type: 'field';
         documentSpec: APICustomActionDocumentSpecifier;

package/src/utils/csi-to-store-docs-converter.ts

@@ -1,34 +1,21 @@
 import _ from 'lodash';
 import { Model, ObjectModel, ImageModel, PageModel, DataModel } from '@stackbit/sdk';
 import { omitByNil } from '@stackbit/utils';
-import {
-    Field,
-    FieldSpecificProps,
-    FieldList,
-    FieldModelProps,
-    FieldObjectProps,
-    isLocalizedField,
-    getLocalizedFieldForLocale,
-    isDocumentFieldOneOfFieldTypes
-} from '@stackbit/types';
-import * as CSITypes from '@stackbit/types';
+import { isLocalizedField, getLocalizedFieldForLocale, isDocumentFieldOneOfFieldTypes } from '@stackbit/types';
+import type * as StackbitTypes from '@stackbit/types';
 
-import * as ContentStoreTypes from '../types';
+import type * as ContentStoreTypes from '../types';
 import { IMAGE_MODEL } from '../common/common-schema';
 import { BackCompatContentSourceInterface } from './backward-compatibility';
 import { getImageFieldsFromSourceData } from './asset-sources-utils';
-import {
-    convertDocumentActionToAPICustomDocumentAction,
-    convertFieldActionToAPICustomAction,
-    convertObjectModelActionToAPICustomObjectAction
-} from './custom-actions';
+import { getDocumentActionsThunk, getFieldActions, getObjectFieldActionsThunk, getObjectModelActionsThunk } from './custom-actions';
 
 export function mapCSIAssetsToStoreAssets({
     csiAssets,
     contentSourceInstance,
     defaultLocaleCode
 }: {
-    csiAssets: CSITypes.Asset[];
+    csiAssets: StackbitTypes.Asset[];
     contentSourceInstance: BackCompatContentSourceInterface;
     defaultLocaleCode?: string;
 }): ContentStoreTypes.Asset[] {
@@ -47,7 +34,7 @@ function sourceAssetToStoreAsset({
     defaultLocaleCode,
     extra
 }: {
-    csiAsset: CSITypes.Asset;
+    csiAsset: StackbitTypes.Asset;
     defaultLocaleCode?: string;
     extra: { srcType: string; srcProjectId: string; srcProjectUrl: string; srcEnvironment: string };
 }): ContentStoreTypes.Asset {
@@ -98,6 +85,9 @@ function sourceAssetToStoreAsset({
  * @param contentSourceInstance
  * @param modelMap
  * @param defaultLocaleCode
+ * @param assetSources
+ * @param createConfigDelegate
+ * @param customActionRunStateMap
  */
 export function mapCSIDocumentsToStoreDocuments({
     csiDocuments,
@@ -106,15 +96,15 @@ export function mapCSIDocumentsToStoreDocuments({
     defaultLocaleCode,
     assetSources,
     createConfigDelegate,
-    customActionMap
+    customActionRunStateMap
 }: {
-    csiDocuments: CSITypes.Document[];
+    csiDocuments: StackbitTypes.Document[];
     contentSourceInstance: BackCompatContentSourceInterface;
     modelMap: Record<string, Model>;
     defaultLocaleCode?: string;
-    assetSources: CSITypes.AssetSource[];
-    createConfigDelegate: () => CSITypes.ConfigDelegate;
-    customActionMap: ContentStoreTypes.ContentStoreCustomActionMap;
+    assetSources: StackbitTypes.AssetSource[];
+    createConfigDelegate: () => StackbitTypes.ConfigDelegate;
+    customActionRunStateMap: ContentStoreTypes.CustomActionRunStateMap;
 }): ContentStoreTypes.Document[] {
     const meta = getMetadataFromContentStore({ contentSourceInstance });
     return csiDocuments.map((csiDocument) =>
@@ -126,7 +116,7 @@ export function mapCSIDocumentsToStoreDocuments({
             meta,
             assetSources,
             createConfigDelegate,
-            customActionMap
+            customActionRunStateMap
         })
     );
 }
@@ -139,23 +129,23 @@ function mapCSIDocumentToStoreDocument({
     meta,
     assetSources,
     createConfigDelegate,
-    customActionMap
+    customActionRunStateMap
 }: {
-    csiDocument: CSITypes.Document;
+    csiDocument: StackbitTypes.Document;
     model: Model;
     modelMap: Record<string, Model>;
     defaultLocaleCode?: string;
     meta: { srcType: string; srcProjectId: string; srcProjectUrl: string; srcEnvironment: string };
-    assetSources: CSITypes.AssetSource[];
-    createConfigDelegate: () => CSITypes.ConfigDelegate;
-    customActionMap: ContentStoreTypes.ContentStoreCustomActionMap;
+    assetSources: StackbitTypes.AssetSource[];
+    createConfigDelegate: () => StackbitTypes.ConfigDelegate;
+    customActionRunStateMap: ContentStoreTypes.CustomActionRunStateMap;
 }): ContentStoreTypes.Document {
     return omitByNil({
         type: 'document',
         ...meta,
         srcObjectId: csiDocument.id,
         srcObjectUrl: csiDocument.manageUrl,
-        getPreview: ({ delegate, locale }: { delegate?: CSITypes.ConfigDelegate; locale?: string }) =>
+        getPreview: ({ delegate, locale }: { delegate?: StackbitTypes.ConfigDelegate; locale?: string }) =>
             getDocumentPreview({
                 csiDocument,
                 model,
@@ -173,14 +163,13 @@ function mapCSIDocumentToStoreDocument({
         updatedAt: csiDocument.updatedAt,
         updatedBy: csiDocument.updatedBy,
         locale: getDocumentLocale({ csiDocument, model }),
-        getDocumentActions: () =>
-            getDocumentActions({
-                csiDocument,
-                model: model as PageModel | DataModel,
-                srcType: meta.srcType,
-                srcProjectId: meta.srcProjectId,
-                customActionMap
-            }),
+        getDocumentActions: getDocumentActionsThunk({
+            csiDocument,
+            model: model as PageModel | DataModel,
+            srcType: meta.srcType,
+            srcProjectId: meta.srcProjectId,
+            customActionRunStateMap
+        }),
         fields: mapCSIFieldsToStoreFields({
             csiDocumentFields: csiDocument.fields,
             modelFields: model.fields ?? [],
@@ -192,7 +181,7 @@ function mapCSIDocumentToStoreDocument({
                 defaultLocaleCode,
                 assetSources,
                 createConfigDelegate,
-                customActionMap,
+                customActionRunStateMap,
                 fieldPath: []
             }
         })
@@ -202,12 +191,12 @@ function mapCSIDocumentToStoreDocument({
 type MapContext = {
     srcType: string;
     srcProjectId: string;
-    parentDocument: CSITypes.Document;
+    parentDocument: StackbitTypes.Document;
     modelMap: Record<string, Model>;
     defaultLocaleCode?: string;
-    assetSources: CSITypes.AssetSource[];
-    createConfigDelegate: () => CSITypes.ConfigDelegate;
-    customActionMap: ContentStoreTypes.ContentStoreCustomActionMap;
+    assetSources: StackbitTypes.AssetSource[];
+    createConfigDelegate: () => StackbitTypes.ConfigDelegate;
+    customActionRunStateMap: ContentStoreTypes.CustomActionRunStateMap;
     fieldPath: (string | number)[];
 };
 
@@ -216,8 +205,8 @@ function mapCSIFieldsToStoreFields({
     modelFields,
     context
 }: {
-    csiDocumentFields: Record<string, CSITypes.DocumentField>;
-    modelFields: Field[];
+    csiDocumentFields: Record<string, StackbitTypes.DocumentField>;
+    modelFields: StackbitTypes.Field[];
     context: MapContext;
 }): Record<string, ContentStoreTypes.DocumentField> {
     return modelFields.reduce((result: Record<string, ContentStoreTypes.DocumentField>, modelField) => {
@@ -234,17 +223,15 @@ function mapCSIFieldsToStoreFields({
         });
         docField.label = modelField.label;
         if (Array.isArray(modelField.actions)) {
-            docField.getFieldActions = ({ locale }: { locale?: string } = {}) => {
-                return getFieldActions({
+            docField.getFieldActions = ({ locale }: { locale?: string } = {}) =>
+                getFieldActions({
                     modelField,
                     csiParentDocument: context.parentDocument,
                     srcType: context.srcType,
                     srcProjectId: context.srcProjectId,
-                    customActionMap: context.customActionMap,
-                    fieldPath: fieldPath,
-                    locale
+                    customActionRunStateMap: context.customActionRunStateMap,
+                    fieldPath: locale ? fieldPath.concat(locale) : fieldPath
                 });
-            };
         }
         result[modelField.name] = docField;
         return result;
@@ -257,8 +244,8 @@ function mapCSIFieldToStoreField({
     localized,
     context
 }: {
-    csiDocumentField: CSITypes.DocumentField | undefined;
-    modelField: Field | FieldSpecificProps;
+    csiDocumentField: StackbitTypes.DocumentField | undefined;
+    modelField: StackbitTypes.Field | StackbitTypes.FieldSpecificProps;
     localized?: boolean;
     context: MapContext;
 }): ContentStoreTypes.DocumentField {
@@ -309,16 +296,16 @@ function mapCSIFieldToStoreField({
         case 'cross-reference':
             return mapCrossReferenceField(csiDocumentField);
         case 'object':
-            return mapObjectField(csiDocumentField as CSITypes.DocumentObjectField, modelField, context);
+            return mapObjectField(csiDocumentField as StackbitTypes.DocumentObjectField, modelField, context);
         case 'model':
-            return mapModelField(csiDocumentField as CSITypes.DocumentModelField, modelField, context);
+            return mapModelField(csiDocumentField as StackbitTypes.DocumentModelField, modelField, context);
         case 'list':
             // list can not be in list, so modelField must be FieldList
-            return mapListField(csiDocumentField as CSITypes.DocumentListField, modelField as FieldList, context);
+            return mapListField(csiDocumentField as StackbitTypes.DocumentListField, modelField as StackbitTypes.FieldList, context);
         case 'richText':
-            return mapRichTextField(csiDocumentField as CSITypes.DocumentRichTextField);
+            return mapRichTextField(csiDocumentField as StackbitTypes.DocumentRichTextField);
         case 'markdown':
-            return mapMarkdownField(csiDocumentField as CSITypes.DocumentStringLikeField);
+            return mapMarkdownField(csiDocumentField as StackbitTypes.DocumentStringLikeField);
         default: {
             const _exhaustiveCheck: never = modelField;
             return _exhaustiveCheck;
@@ -327,9 +314,9 @@ function mapCSIFieldToStoreField({
 }
 
 function mapImageField(
-    csiDocumentField: CSITypes.DocumentField,
-    imageModelField: CSITypes.FieldImageProps,
-    assetSources: CSITypes.AssetSource[]
+    csiDocumentField: StackbitTypes.DocumentField,
+    imageModelField: StackbitTypes.FieldImageProps,
+    assetSources: StackbitTypes.AssetSource[]
 ): ContentStoreTypes.DocumentImageField {
     // the image can be remapped from 'string', 'text' or 'json' fields
     if (isDocumentFieldOneOfFieldTypes(csiDocumentField, ['string', 'text', 'json'])) {
@@ -413,7 +400,7 @@ function mapImageField(
     });
 }
 
-function mapCrossReferenceField(csiDocumentField: CSITypes.DocumentField): ContentStoreTypes.DocumentCrossReferenceField {
+function mapCrossReferenceField(csiDocumentField: StackbitTypes.DocumentField): ContentStoreTypes.DocumentCrossReferenceField {
     const unlocalizedUnset = {
         type: 'cross-reference',
         refType: 'document',
@@ -507,11 +494,11 @@ function mapCrossReferenceField(csiDocumentField: CSITypes.DocumentField): Conte
 }
 
 function mapObjectField(
-    csiDocumentField: CSITypes.DocumentObjectField,
-    modelField: FieldObjectProps,
+    csiDocumentField: StackbitTypes.DocumentObjectField,
+    modelField: StackbitTypes.FieldObjectProps,
     context: MapContext
 ): ContentStoreTypes.DocumentObjectField {
-    const _getObjectPreview = ({ delegate, locale }: { delegate?: CSITypes.ConfigDelegate; locale?: string }) => {
+    const _getObjectPreview = ({ delegate, locale }: { delegate?: StackbitTypes.ConfigDelegate; locale?: string }) => {
         return getObjectPreview({
             parentDocument: context.parentDocument,
             documentField: csiDocumentField,
@@ -522,13 +509,13 @@ function mapObjectField(
             locale
         }) as ContentStoreTypes.DocumentObjectFieldPreview;
     };
-    const _getObjectActions = (fieldPath: (string | number)[]) => () =>
-        getObjectFieldActions({
+    const _getObjectActions = (fieldPath: (string | number)[]) =>
+        getObjectFieldActionsThunk({
             modelField: modelField,
             csiParentDocument: context.parentDocument,
             srcType: context.srcType,
             srcProjectId: context.srcProjectId,
-            customActionMap: context.customActionMap,
+            customActionRunStateMap: context.customActionRunStateMap,
             fieldPath: fieldPath
         });
     if (!isLocalizedField(csiDocumentField)) {
@@ -565,10 +552,14 @@ function mapObjectField(
     };
 }
 
-function mapModelField(csiDocumentField: CSITypes.DocumentModelField, modelField: FieldModelProps, context: MapContext): ContentStoreTypes.DocumentModelField {
+function mapModelField(
+    csiDocumentField: StackbitTypes.DocumentModelField,
+    modelField: StackbitTypes.FieldModelProps,
+    context: MapContext
+): ContentStoreTypes.DocumentModelField {
     const _getObjectPreview =
         (model: ObjectModel) =>
-        ({ delegate, locale }: { delegate?: CSITypes.ConfigDelegate; locale?: string }) => {
+        ({ delegate, locale }: { delegate?: StackbitTypes.ConfigDelegate; locale?: string }) => {
             return getObjectPreview({
                 parentDocument: context.parentDocument,
                 documentField: csiDocumentField,
@@ -579,13 +570,13 @@ function mapModelField(csiDocumentField: CSITypes.DocumentModelField, modelField
                 locale
             }) as ContentStoreTypes.DocumentModelFieldPreview;
         };
-    const _getObjectActions = (model: ObjectModel, fieldPath: (string | number)[]) => () =>
-        getObjectModelActions({
+    const _getObjectActions = (model: ObjectModel, fieldPath: (string | number)[]) =>
+        getObjectModelActionsThunk({
             csiParentDocument: context.parentDocument,
             model: model,
             srcType: context.srcType,
             srcProjectId: context.srcProjectId,
-            customActionMap: context.customActionMap,
+            customActionRunStateMap: context.customActionRunStateMap,
             fieldPath: fieldPath
         });
     if (!isLocalizedField(csiDocumentField)) {
@@ -628,7 +619,11 @@ function mapModelField(csiDocumentField: CSITypes.DocumentModelField, modelField
     };
 }
 
-function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField: FieldList, context: MapContext): ContentStoreTypes.DocumentListField {
+function mapListField(
+    csiDocumentField: StackbitTypes.DocumentListField,
+    modelField: StackbitTypes.FieldList,
+    context: MapContext
+): ContentStoreTypes.DocumentListField {
     if (!isLocalizedField(csiDocumentField)) {
         return {
             type: csiDocumentField.type,
@@ -671,7 +666,7 @@ function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField:
     };
 }
 
-function mapRichTextField(csiDocumentField: CSITypes.DocumentRichTextField): ContentStoreTypes.DocumentRichTextField {
+function mapRichTextField(csiDocumentField: StackbitTypes.DocumentRichTextField): ContentStoreTypes.DocumentRichTextField {
     if (!isLocalizedField(csiDocumentField)) {
         return {
             ...csiDocumentField,
@@ -690,7 +685,7 @@ function mapRichTextField(csiDocumentField: CSITypes.DocumentRichTextField): Con
     };
 }
 
-function mapMarkdownField(csiDocumentField: CSITypes.DocumentStringLikeField): ContentStoreTypes.DocumentMarkdownField {
+function mapMarkdownField(csiDocumentField: StackbitTypes.DocumentStringLikeField): ContentStoreTypes.DocumentMarkdownField {
     if (!isLocalizedField(csiDocumentField)) {
         return {
             type: 'markdown',
@@ -724,7 +719,7 @@ function getMetadataFromContentStore({ contentSourceInstance }: { contentSourceI
     };
 }
 
-export function getDocumentLocale({ csiDocument, model }: { csiDocument: CSITypes.Document; model: Model }): string | undefined {
+export function getDocumentLocale({ csiDocument, model }: { csiDocument: StackbitTypes.Document; model: Model }): string | undefined {
     if (csiDocument.locale) {
         return csiDocument.locale;
     }
@@ -741,11 +736,11 @@ export function getDocumentPreview({
     delegate,
     locale
 }: {
-    csiDocument: CSITypes.Document;
+    csiDocument: StackbitTypes.Document;
     model: Model;
     srcType: string;
     srcProjectId: string;
-    delegate: CSITypes.ConfigDelegate;
+    delegate: StackbitTypes.ConfigDelegate;
     locale?: string;
 }): ContentStoreTypes.DocumentPreview {
     let previewTitle: string | undefined;
@@ -781,7 +776,7 @@ export function getDocumentPreview({
     return { previewTitle };
 }
 
-function getObjectPreview<Type extends CSITypes.DocumentModelField | CSITypes.DocumentObjectField>({
+function getObjectPreview<Type extends StackbitTypes.DocumentModelField | StackbitTypes.DocumentObjectField>({
     parentDocument,
     documentField,
     objectModelOrObjectField,
@@ -790,12 +785,12 @@ function getObjectPreview<Type extends CSITypes.DocumentModelField | CSITypes.Do
     delegate,
     locale
 }: {
-    parentDocument: CSITypes.Document;
+    parentDocument: StackbitTypes.Document;
     documentField: Type;
-    objectModelOrObjectField: Type extends CSITypes.DocumentModelField ? ObjectModel : CSITypes.FieldObjectProps;
+    objectModelOrObjectField: Type extends StackbitTypes.DocumentModelField ? ObjectModel : StackbitTypes.FieldObjectProps;
     srcType: string;
     srcProjectId: string;
-    delegate: CSITypes.ConfigDelegate;
+    delegate: StackbitTypes.ConfigDelegate;
     locale?: string;
 }): ContentStoreTypes.DocumentObjectFieldPreview {
     let previewTitle: string | undefined;
@@ -839,10 +834,10 @@ function resolveDocumentLabelForFieldPath({
     fieldPath,
     delegate
 }: {
-    document: CSITypes.DocumentWithSource;
-    fromField?: CSITypes.DocumentModelField | CSITypes.DocumentObjectField;
+    document: StackbitTypes.DocumentWithSource;
+    fromField?: StackbitTypes.DocumentModelField | StackbitTypes.DocumentObjectField;
     fieldPath: string;
-    delegate: CSITypes.ConfigDelegate;
+    delegate: StackbitTypes.ConfigDelegate;
 }): string | undefined {
     const documentField = delegate.getDocumentFieldForFieldPath({
         document: document,
@@ -862,10 +857,10 @@ function getObjectTitleFromLabelField({
     delegate,
     locale
 }: {
-    document: CSITypes.DocumentWithSource;
-    documentField?: CSITypes.DocumentModelField | CSITypes.DocumentObjectField;
-    modelOrObjectField: Model | FieldObjectProps | ImageModel;
-    delegate: CSITypes.ConfigDelegate;
+    document: StackbitTypes.DocumentWithSource;
+    documentField?: StackbitTypes.DocumentModelField | StackbitTypes.DocumentObjectField;
+    modelOrObjectField: Model | StackbitTypes.FieldObjectProps | ImageModel;
+    delegate: StackbitTypes.ConfigDelegate;
     locale?: string;
 }): string | undefined {
     const labelField = modelOrObjectField.labelField;
@@ -880,7 +875,7 @@ function getObjectTitleFromLabelField({
     });
 }
 
-function getAssetLabel(csiAsset: CSITypes.Asset, locale?: string): string {
+function getAssetLabel(csiAsset: StackbitTypes.Asset, locale?: string): string {
     const imageModel = IMAGE_MODEL;
     let label = getAssetLabelFromLabelField(csiAsset, imageModel, locale);
     if (!label) {
@@ -889,7 +884,7 @@ function getAssetLabel(csiAsset: CSITypes.Asset, locale?: string): string {
     return label;
 }
 
-function getAssetLabelFromLabelField(csiAsset: CSITypes.Asset, imageModel: ImageModel, locale?: string): string | undefined {
+function getAssetLabelFromLabelField(csiAsset: StackbitTypes.Asset, imageModel: ImageModel, locale?: string): string | undefined {
     const labelField = imageModel.labelField;
     if (!labelField) {
         return;
@@ -898,7 +893,7 @@ function getAssetLabelFromLabelField(csiAsset: CSITypes.Asset, imageModel: Image
     if (!field) {
         return;
     }
-    const localizedField = getLocalizedFieldForLocale(field as CSITypes.DocumentField, locale);
+    const localizedField = getLocalizedFieldForLocale(field as StackbitTypes.DocumentField, locale);
     if (localizedField && 'value' in localizedField && localizedField.value) {
         return localizedField.value;
     }
@@ -907,136 +902,3 @@ function getAssetLabelFromLabelField(csiAsset: CSITypes.Asset, imageModel: Image
 function getObjectTitleFromModel(model: Model | ImageModel): string {
     return model.label ? model.label : _.startCase(model.name);
 }
-
-function getDocumentActions({
-    csiDocument,
-    model,
-    srcType,
-    srcProjectId,
-    customActionMap
-}: {
-    csiDocument: CSITypes.Document;
-    model: PageModel | DataModel;
-    srcType: string;
-    srcProjectId: string;
-    customActionMap: ContentStoreTypes.ContentStoreCustomActionMap;
-}): ContentStoreTypes.APICustomActionDocument[] | undefined {
-    if (!('actions' in model) || !Array.isArray(model.actions)) {
-        return undefined;
-    }
-    return model.actions.map((action) => {
-        return convertDocumentActionToAPICustomDocumentAction({
-            action,
-            customActionMap,
-            csiDocument: {
-                ...csiDocument,
-                srcType,
-                srcProjectId
-            }
-        });
-    });
-}
-
-function getObjectModelActions({
-    model,
-    csiParentDocument,
-    srcType,
-    srcProjectId,
-    customActionMap,
-    fieldPath
-}: {
-    model: ObjectModel;
-    csiParentDocument: CSITypes.Document;
-    srcType: string;
-    srcProjectId: string;
-    customActionMap: ContentStoreTypes.ContentStoreCustomActionMap;
-    fieldPath: (string | number)[];
-}): ContentStoreTypes.APICustomActionObject[] | undefined {
-    if (!('actions' in model) || !Array.isArray(model.actions)) {
-        return undefined;
-    }
-    return model.actions.map((action) => {
-        return convertObjectModelActionToAPICustomObjectAction({
-            action,
-            customActionMap,
-            fieldPath: fieldPath,
-            csiParentDocument: {
-                ...csiParentDocument,
-                srcType,
-                srcProjectId
-            }
-        });
-    });
-}
-
-function getObjectFieldActions({
-    modelField,
-    csiParentDocument,
-    srcType,
-    srcProjectId,
-    customActionMap,
-    fieldPath,
-    locale
-}: {
-    modelField: FieldObjectProps;
-    csiParentDocument: CSITypes.Document;
-    srcType: string;
-    srcProjectId: string;
-    customActionMap: ContentStoreTypes.ContentStoreCustomActionMap;
-    fieldPath: (string | number)[];
-    locale?: string;
-}): ContentStoreTypes.APICustomActionObject[] | undefined {
-    if (!('actions' in modelField) || !Array.isArray(modelField.actions)) {
-        return undefined;
-    }
-    return modelField.actions
-        .filter((action): action is CSITypes.CustomActionObjectField => action.type === 'object')
-        .map((action) => {
-            return convertFieldActionToAPICustomAction({
-                action,
-                customActionMap,
-                fieldPath: locale ? fieldPath.concat(locale) : fieldPath,
-                csiParentDocument: {
-                    ...csiParentDocument,
-                    srcType,
-                    srcProjectId
-                }
-            });
-        });
-}
-
-function getFieldActions({
-    modelField,
-    csiParentDocument,
-    srcType,
-    srcProjectId,
-    customActionMap,
-    fieldPath,
-    locale
-}: {
-    modelField: FieldSpecificProps;
-    csiParentDocument: CSITypes.Document;
-    srcType: string;
-    srcProjectId: string;
-    customActionMap: ContentStoreTypes.ContentStoreCustomActionMap;
-    fieldPath: (string | number)[];
-    locale?: string;
-}): ContentStoreTypes.APICustomActionField[] | undefined {
-    if (!('actions' in modelField) || !Array.isArray(modelField.actions)) {
-        return undefined;
-    }
-    return modelField.actions
-        .filter((action): action is CSITypes.CustomActionField => action.type !== 'object')
-        .map((action) => {
-            return convertFieldActionToAPICustomAction({
-                action,
-                customActionMap,
-                fieldPath: locale ? fieldPath.concat(locale) : fieldPath,
-                csiParentDocument: {
-                    ...csiParentDocument,
-                    srcType,
-                    srcProjectId
-                }
-            });
-        });
-}