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

package/src/utils/custom-actions.ts

@@ -1,5 +1,5 @@
 import _ from 'lodash';
-import { Config, PageModel, DataModel, FieldObjectProps, FieldSpecificProps, mapModelFieldsRecursively, ObjectModel } from '@stackbit/sdk';
+import { Config } from '@stackbit/sdk';
 import * as StackbitTypes from '@stackbit/types';
 import { mapPromise, omitByNil } from '@stackbit/utils';
 import * as ContentStoreTypes from '../types';
@@ -7,14 +7,10 @@ import {
     CustomActionStateChange,
     APICustomAction,
     APICustomActionDocumentSpecifier,
-    APICustomActionDocument,
-    APICustomActionObject,
-    APICustomActionField,
     APIGetCustomActionRequest,
     APIRunCustomActionRequest,
     APIRunCustomActionRequestBulk,
     CustomActionRunStateMap,
-    ExtendedCustomActionDocument,
     ExtendedCustomActionObjectModel,
     ExtendedCustomActionField,
     APICustomActionGlobal,
@@ -28,30 +24,6 @@ import { mapStoreDocumentToCSIDocumentWithSource, mapStoreFieldToCSIField } from
 import { getModelAndDocumentFieldForLocalizedFieldPath } from './field-path-utils';
 import { getContentSourceDataByTypeAndProjectIdOrThrow, getUserContextForSrcTypeThunk } from '../content-store-utils';
 
-/**
- * Removes "run" and "state" functions from actions of models, nested objects and fields.
- * Sets "needsResolving" flag to let client know if the action needs additional resolving.
- * @param {StackbitTypes.ModelMap} modelMap
- */
-export function stripModelActions({ modelMap }: { modelMap: StackbitTypes.ModelMap }): StackbitTypes.ModelMap {
-    return _.mapValues(modelMap, (model) => {
-        if ('actions' in model) {
-            const { actions, ...restModel } = model;
-            model = restModel;
-        }
-
-        model = mapModelFieldsRecursively(model, (field) => {
-            if ('actions' in field && Array.isArray(field.actions)) {
-                const { actions, ...restField } = field;
-                field = restField;
-            }
-            return field;
-        });
-
-        return model;
-    });
-}
-
 export async function getGlobalAndBulkAPIActions({
     stackbitConfig,
     customActionRunStateMap,
@@ -113,204 +85,6 @@ export async function getGlobalAndBulkAPIActions({
     });
 }
 
-export function getDocumentActionsThunk({
-    csiDocument,
-    model,
-    srcType,
-    srcProjectId,
-    customActionRunStateMap
-}: {
-    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;
-    }
-
-    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 getObjectModelActionsThunk({
-    model,
-    csiParentDocument,
-    srcType,
-    srcProjectId,
-    customActionRunStateMap,
-    fieldPath
-}: {
-    model: ObjectModel;
-    csiParentDocument: StackbitTypes.Document;
-    srcType: string;
-    srcProjectId: string;
-    customActionRunStateMap: ContentStoreTypes.CustomActionRunStateMap;
-    fieldPath: (string | number)[];
-}): () => ContentStoreTypes.APICustomActionObject[] | undefined {
-    if (!('actions' in model) || !Array.isArray(model.actions)) {
-        return () => undefined;
-    }
-
-    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 getObjectFieldActionsThunk({
-    modelField,
-    csiParentDocument,
-    srcType,
-    srcProjectId,
-    customActionRunStateMap,
-    fieldPath
-}: {
-    modelField: FieldObjectProps;
-    csiParentDocument: StackbitTypes.Document;
-    srcType: string;
-    srcProjectId: string;
-    customActionRunStateMap: ContentStoreTypes.CustomActionRunStateMap;
-    fieldPath: (string | number)[];
-}): () => 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
-        };
-        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
-        };
-    });
-
-    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 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,
     customActionRunStateMap,
@@ -620,28 +394,6 @@ 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({
     extendedAction,
     contentSourceDataById
@@ -733,10 +485,10 @@ function getHandlerParamsForFieldAction({
     }) as {
         // list items cannot have actions, therefore we can safely reduce the type to non list item fields
         modelField: StackbitTypes.Field;
-        documentField: ContentStoreTypes.DocumentField;
+        documentField?: ContentStoreTypes.DocumentField;
     };
 
-    const csiDocumentField = mapStoreFieldToCSIField(documentField);
+    const csiDocumentField = documentField ? mapStoreFieldToCSIField(documentField) : undefined;
 
     return {
         parentDocument: mappedCSIDocument,
@@ -882,7 +634,7 @@ function findCustomActionById({
         }
 
         if (modelField.type === 'model') {
-            if (documentField.type !== 'model' || documentField.localized || documentField.isUnset) {
+            if (!documentField || documentField.type !== 'model' || documentField.localized || documentField.isUnset) {
                 return undefined;
             }
             const modelName = documentField.srcModelName;
@@ -925,31 +677,6 @@ function getGlobalActionNameFromId(actionId: string) {
     return actionId.substring('config.actions.'.length);
 }
 
-function documentActionId({ srcType, srcProjectId, srcDocumentId, actionName }: APICustomActionDocumentSpecifier & { actionName: string }): string {
-    return JSON.stringify({
-        srcType,
-        srcProjectId,
-        srcDocumentId,
-        actionName
-    });
-}
-
-function fieldPathActionId({
-    srcType,
-    srcProjectId,
-    srcDocumentId,
-    fieldPath,
-    actionName
-}: APICustomActionDocumentSpecifier & { fieldPath: (string | number)[]; actionName: string }): string {
-    return JSON.stringify({
-        srcType,
-        srcProjectId,
-        srcDocumentId,
-        fieldPath,
-        actionName
-    });
-}
-
 function parseActionId(actionId: string):
     | {
           srcType?: string;

package/src/utils/field-path-utils.ts

@@ -532,7 +532,7 @@ export function getModelAndDocumentFieldForLocalizedFieldPath({
     fieldPath: (string | number)[];
     modelMap: Record<string, Model>;
     isFullFieldPath?: boolean;
-}): { modelField: Field | FieldListItems; documentField: ContentStoreTypes.DocumentField | ContentStoreTypes.DocumentListFieldItems } {
+}): { modelField: Field | FieldListItems; documentField?: ContentStoreTypes.DocumentField | ContentStoreTypes.DocumentListFieldItems } {
     if (isFullFieldPath) {
         if (_.head(fieldPath) !== 'fields') {
             throw new Error('fieldPath must start with "fields" specifier');
@@ -566,7 +566,7 @@ export function getModelAndDocumentFieldForLocalizedFieldPath({
         docField: ContentStoreTypes.DocumentField | ContentStoreTypes.DocumentListFieldItems,
         modelField: Field | FieldListItems,
         fieldPath: (string | number)[]
-    ): { modelField: Field | FieldListItems; documentField: ContentStoreTypes.DocumentField | ContentStoreTypes.DocumentListFieldItems } {
+    ): { modelField: Field | FieldListItems; documentField?: ContentStoreTypes.DocumentField | ContentStoreTypes.DocumentListFieldItems } {
         // if no more items in fieldPath return the found document and model fields
         if (fieldPath.length === 0) {
             return {
@@ -589,6 +589,10 @@ export function getModelAndDocumentFieldForLocalizedFieldPath({
             fieldPath = _.tail(fieldPath);
             const localizedDocField = getDocumentFieldForLocale(docField, locale);
             if (!localizedDocField) {
+                if (!fieldPath.length) {
+                    // field locale is not set
+                    return { modelField, documentField: undefined };
+                }
                 throw new Error(`fieldPath '${origFieldPath.join('.')}' doesn't specify the locale`);
             }
             docField = localizedDocField;

package/src/utils/model-utils.ts

@@ -1,6 +1,5 @@
 import _ from 'lodash';
-
-import { FieldCrossReferenceModel, Logger, ModelWithSource } from '@stackbit/types';
+import { FieldCrossReferenceModel, Logger, ModelWithSource, CustomActionField, CustomActionObjectField } from '@stackbit/types';
 import {
     Model,
     assignLabelFieldIfNeeded,
@@ -43,6 +42,18 @@ export function normalizeModels({ models, logger }: { models: ModelWithSource[];
 
         assignLabelFieldIfNeeded(model);
 
+        if ((model.type === 'data' || model.type === 'page') && model.actions) {
+            model.actions = model.actions.map((action) => ({
+                ...action,
+                type: 'document'
+            }));
+        } else if (model.type === 'object' && model.actions) {
+            model.actions = model.actions.map((action) => ({
+                ...action,
+                type: 'object'
+            }));
+        }
+
         model = mapModelFieldsRecursively(model, (field) => {
             field = { ...field };
 
@@ -50,6 +61,13 @@ export function normalizeModels({ models, logger }: { models: ModelWithSource[];
                 field.label = _.startCase(field.name);
             }
 
+            if (field.actions) {
+                field.actions = field.actions.map((action) => ({
+                    ...action,
+                    type: action.type ?? 'field'
+                })) as (CustomActionField | CustomActionObjectField)[];
+            }
+
             mapListItemsPropsOrSelfSpecificProps(field, (listItemsPropsOrField) => {
                 if (isObjectField(listItemsPropsOrField)) {
                     assignLabelFieldIfNeeded(listItemsPropsOrField);