@stackbit/cms-core 0.7.6-develop.2 → 0.8.0-develop.1

package/src/content-store-utils.ts

@@ -14,6 +14,23 @@ export function getContentSourceId(contentSourceType: string, srcProjectId: stri
     return contentSourceType + ':' + srcProjectId;
 }
 
+export function getContentSourceDataByTypeAndProjectIdOrThrow(
+    srcType: string,
+    srcProjectId: string,
+    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>
+) {
+    const contentSourceId = getContentSourceId(srcType, srcProjectId);
+    return getContentSourceDataByIdOrThrow(contentSourceId, contentSourceDataById);
+}
+
+export function getContentSourceDataByIdOrThrow(contentSourceId: string, contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>) {
+    const contentSourceData = contentSourceDataById[contentSourceId];
+    if (!contentSourceData) {
+        throw new Error(`Content source not found: '${contentSourceId}'.`);
+    }
+    return contentSourceData;
+}
+
 export function findContentSourcesDataForTypeOrId({
     contentSourceDataById,
     srcType,
@@ -30,6 +47,10 @@ export function findContentSourcesDataForTypeOrId({
     });
 }
 
+export function getUserContextForSrcTypeThunk(user?: ContentStoreTypes.User) {
+    return (srcType: string) => getUserContextForSrcType(srcType, user);
+}
+
 export function getUserContextForSrcType(srcType: string, user?: ContentStoreTypes.User): CSITypes.User | undefined {
     if (!user) {
         return undefined;
@@ -184,6 +205,232 @@ export function getModelFieldForFieldAtPath(
     return getField(childDocField, childModelField, childFieldPath);
 }
 
+/**
+ * Returns a model field and a document field at the specified field path.
+ *
+ * If some fields along the fieldPath are localized, the fieldPath must
+ * container the locale of the field under the "locales" property. The locales
+ * along the field path don't have to be the same.
+ * @example
+ * fieldPath: ['fields', 'button', 'locales', 'en', 'fields', 'title', 'locales', 'es']
+ *
+ * If the provided fieldPath points to a list item, the returned model field
+ * and document field will belong to a list item. In this case, the model field
+ * will contain only field-specific properties and the document field will be
+ * localized.
+ * @example
+ * fieldPath: ['fields', 'buttons', 'items', 2]
+ *
+ * The "fullFieldPath" flag specifies if the fieldPath includes container specifiers
+ * such as "fields", "items" and "locales".
+ * @example
+ * fullFieldPath: false => fieldPath: ['sections', 1, 'title', 'es']
+ * fullFieldPath: true => fieldPath: ['fields', 'sections', 'items', 1, 'fields', 'title', 'locales', 'es']
+ *
+ * @param document
+ * @param model
+ * @param fieldPath
+ * @param modelMap
+ * @param fullFieldPath
+ */
+export function getModelAndDocumentFieldForLocalizedFieldPath({
+    document,
+    model,
+    fieldPath,
+    modelMap,
+    fullFieldPath
+}: {
+    document: ContentStoreTypes.Document;
+    model: Model;
+    fieldPath: (string | number)[];
+    modelMap: Record<string, Model>;
+    fullFieldPath?: boolean;
+}): { modelField: Field | FieldListItems; documentField: ContentStoreTypes.DocumentField | ContentStoreTypes.DocumentListFieldItems } {
+    const origFieldPath = fieldPath;
+    if (fullFieldPath) {
+        if (_.head(fieldPath) !== 'fields') {
+            throw new Error('fieldPath must start with "fields" specifier');
+        }
+        fieldPath = _.tail(fieldPath);
+    }
+    if (_.isEmpty(fieldPath)) {
+        throw new Error('the fieldPath can not be empty');
+    }
+
+    function getFieldPathPrefixOfTail(fieldPath: (string | number)[]) {
+        return origFieldPath.slice(0, origFieldPath.length - fieldPath.length);
+    }
+
+    function getField(
+        docField: ContentStoreTypes.DocumentField | ContentStoreTypes.DocumentListFieldItems,
+        modelField: Field | FieldListItems,
+        fieldPath: (string | number)[]
+    ): { modelField: Field | FieldListItems; documentField: ContentStoreTypes.DocumentField | ContentStoreTypes.DocumentListFieldItems } {
+        if (docField.localized) {
+            if (fullFieldPath) {
+                if (_.head(fieldPath) !== 'locales') {
+                    throw new Error('fieldPath must contain "locales" specifier for localized field');
+                }
+                fieldPath = _.tail(fieldPath);
+            }
+            const locale = _.head(fieldPath);
+            if (typeof locale !== 'string') {
+                throw new Error('fieldPath must contain string locale');
+            }
+            fieldPath = _.tail(fieldPath);
+            const localizedDocField = getDocumentFieldForLocale(docField, locale);
+            if (!localizedDocField) {
+                throw new Error(`locale for field was not found`);
+            }
+            docField = localizedDocField;
+        }
+
+        switch (docField.type) {
+            case 'object': {
+                if (docField.isUnset) {
+                    throw new Error(`field is not set`);
+                }
+                if (fullFieldPath) {
+                    if (_.head(fieldPath) !== 'fields') {
+                        throw new Error('fieldPath must contain "fields" specifier for "object" field');
+                    }
+                    fieldPath = _.tail(fieldPath);
+                }
+                const fieldName = _.head(fieldPath);
+                if (typeof fieldName === 'undefined') {
+                    throw new Error('the field path of object must contain a field name');
+                }
+                fieldPath = _.tail(fieldPath);
+
+                const childDocField = docField.fields[fieldName];
+                if (!childDocField) {
+                    throw new Error(`document field doesn't exist at field path: '${getFieldPathPrefixOfTail(fieldPath).join('.')}'`);
+                }
+                if (modelField.type !== 'object') {
+                    throw new Error(`model field type '${modelField.type}' doesn't match document field type '${docField.type}'`);
+                }
+                const childModelField = _.find(modelField.fields, (field) => field.name === fieldName);
+                if (!childModelField) {
+                    throw new Error(`model field doesn't exist at field path: '${getFieldPathPrefixOfTail(fieldPath).join('.')}'`);
+                }
+                if (fieldPath.length === 0) {
+                    return {
+                        modelField: childModelField,
+                        documentField: childDocField
+                    };
+                }
+                return getField(childDocField, childModelField, fieldPath);
+            }
+            case 'model': {
+                if (docField.isUnset) {
+                    throw new Error(`field is not set`);
+                }
+                if (fullFieldPath) {
+                    if (_.head(fieldPath) !== 'fields') {
+                        throw new Error('fieldPath must contain "fields" specifier for "model" field');
+                    }
+                    fieldPath = _.tail(fieldPath);
+                }
+                const fieldName = _.head(fieldPath);
+                if (typeof fieldName === 'undefined') {
+                    throw new Error('the field path of model must contain a field name');
+                }
+                fieldPath = _.tail(fieldPath);
+
+                const modelName = docField.srcModelName;
+                const childModel = modelMap[modelName];
+                if (!childModel) {
+                    throw new Error(`model ${modelName} doesn't exist`);
+                }
+                const childModelField = _.find(childModel.fields, (field) => field.name === fieldName);
+                if (!childModelField) {
+                    throw new Error(`model field doesn't exist at field path: '${getFieldPathPrefixOfTail(fieldPath).join('.')}'`);
+                }
+                const childDocField = docField.fields[fieldName];
+                if (!childDocField) {
+                    throw new Error(`document field doesn't exist at field path: '${getFieldPathPrefixOfTail(fieldPath).join('.')}'`);
+                }
+                if (fieldPath.length === 0) {
+                    return {
+                        modelField: childModelField,
+                        documentField: childDocField
+                    };
+                }
+                return getField(childDocField, childModelField, fieldPath);
+            }
+            case 'list': {
+                if (fullFieldPath) {
+                    if (_.head(fieldPath) !== 'items') {
+                        throw new Error('fieldPath must contain "items" specifier for "list" field');
+                    }
+                    fieldPath = _.tail(fieldPath);
+                }
+                const itemIndex = _.head(fieldPath) as number;
+                if (typeof itemIndex === 'undefined') {
+                    throw new Error('the field path of list must contain an item index');
+                }
+                fieldPath = _.tail(fieldPath);
+
+                const listItem = docField.items && docField.items[itemIndex as number];
+                if (!listItem) {
+                    throw new Error(`list item doesn't exist at field path: '${getFieldPathPrefixOfTail(fieldPath).join('.')}'`);
+                }
+                if (modelField.type !== 'list') {
+                    throw new Error(`model field type '${modelField.type}' doesn't match document field type '${docField.type}'`);
+                }
+                const listItemsModel = modelField.items;
+                if (fieldPath.length === 0) {
+                    return {
+                        modelField: listItemsModel,
+                        documentField: listItem
+                    };
+                }
+                if (!Array.isArray(listItemsModel)) {
+                    return getField(listItem, listItemsModel, fieldPath);
+                } else {
+                    const fieldListItems = (listItemsModel as FieldListItems[]).find((listItemsModel) => listItemsModel.type === listItem.type);
+                    if (!fieldListItems) {
+                        throw new Error(
+                            `cannot find list item model for document field of type '${listItem.type}' at field path: '${getFieldPathPrefixOfTail(
+                                fieldPath
+                            ).join('.')}'`
+                        );
+                    }
+                    return getField(listItem, fieldListItems, fieldPath);
+                }
+            }
+            default:
+                if (!_.isEmpty(fieldPath)) {
+                    throw new Error('illegal fieldPath');
+                }
+                return {
+                    modelField,
+                    documentField: docField
+                };
+        }
+    }
+
+    const fieldName = _.head(fieldPath);
+    const childFieldPath = _.tail(fieldPath);
+
+    if (typeof fieldName !== 'string') {
+        throw new Error('the first fieldPath item must be string');
+    }
+
+    const childDocField: ContentStoreTypes.DocumentField | undefined = document.fields[fieldName];
+    const childModelField: Field | undefined = _.find(model.fields, { name: fieldName });
+
+    if (!childDocField || !childModelField) {
+        throw new Error(`field ${fieldName} doesn't exist`);
+    }
+
+    if (childFieldPath.length === 0) {
+        return { modelField: childModelField, documentField: childDocField };
+    }
+
+    return getField(childDocField, childModelField, childFieldPath);
+}
+
 export function groupModelsByContentSource({ models }: { models: CSITypes.ModelWithSource[] }): Record<string, Record<string, Record<string, Model>>> {
     const modelMapByContentSource: Record<string, Record<string, Record<string, Model>>> = {};
     for (const model of models) {

package/src/content-store.ts

@@ -22,11 +22,12 @@ import { append, DeferredPromise, deferredPromise, deferWhileRunning, mapPromise
 
 import * as ContentStoreTypes from './types';
 import { Timer } from './utils/timer';
-import { SearchFilter } from './types/search-filter';
+import { SearchFilter } from './types';
 import { searchDocuments } from './utils/search-utils';
 import { mapCSIAssetsToStoreAssets, mapCSIDocumentsToStoreDocuments } from './utils/csi-to-store-docs-converter';
 import {
     getContentSourceId,
+    getContentSourceDataByIdOrThrow,
     getContentSourceIdForContentSource,
     getCSIDocumentsAndAssetsFromContentSourceDataByIds,
     getModelFieldForFieldAtPath,
@@ -58,6 +59,7 @@ import { createConfigDelegate, getCreateConfigDelegateThunk } from './utils/conf
 import { GitService } from './services';
 import { getAssetSourcesForClient } from './utils/asset-sources-utils';
 import { deleteDocumentHooked, publishDocumentHooked, updateDocumentHooked } from './utils/document-hooks';
+import { resolveCustomActionsById, getGlobalAndBulkAPIActions, runCustomAction, stripModelActions } from './utils/custom-actions';
 import {
     logCreateDocument,
     logDeleteDocument,
@@ -82,6 +84,7 @@ export interface ContentSourceOptions {
     userCommandSpawner?: UserCommandSpawner; //TODO remove
     onSchemaChangeCallback: () => void;
     onContentChangeCallback: (contentChanges: ContentStoreTypes.ContentChangeResult) => void;
+    onActionStateChangeCallback: (actionResult: ContentStoreTypes.CustomActionStateChange) => void;
     handleConfigAssets: HandleConfigAssets;
     devAppRestartNeeded?: () => void;
 }
@@ -127,6 +130,7 @@ export class ContentStore {
     private readonly git: GitService;
     private readonly onSchemaChangeCallback: () => void;
     private readonly onContentChangeCallback: (contentChanges: ContentStoreTypes.ContentChangeResult) => void;
+    private readonly onActionStateChangeCallback: (actionStateChange: ContentStoreTypes.CustomActionStateChange) => void;
     private readonly handleConfigAssets: HandleConfigAssets;
     private readonly devAppRestartNeeded?: () => void;
     private contentSources: BackCompatContentSourceInterface[] = [];
@@ -142,6 +146,7 @@ export class ContentStore {
     private processingContentSourcesPromise: DeferredPromise<void> | null = null;
     private contentStoreEventQueue: ContentStoreEventQueue = [];
     private treeViews: CSITypes.TreeViewNode[] = [];
+    private customActionMap: ContentStoreTypes.ContentStoreCustomActionMap = {};
 
     constructor(options: ContentSourceOptions) {
         this.logger = options.logger.createLogger({ label: 'content-store' });
@@ -154,6 +159,7 @@ export class ContentStore {
         this.userCommandSpawner = options.userCommandSpawner;
         this.onSchemaChangeCallback = options.onSchemaChangeCallback;
         this.onContentChangeCallback = options.onContentChangeCallback;
+        this.onActionStateChangeCallback = options.onActionStateChangeCallback;
         this.handleConfigAssets = options.handleConfigAssets;
         this.contentUpdatesWatchTimer = new Timer({ timerCallback: () => this.handleTimerTimeout(), logger: this.logger });
         this.devAppRestartNeeded = options.devAppRestartNeeded;
@@ -1040,6 +1046,7 @@ export class ContentStore {
             modelMap: contentSourceData.modelMap,
             defaultLocaleCode: contentSourceData.defaultLocaleCode,
             assetSources: this.stackbitConfig?.assetSources ?? [],
+            customActionMap: this.customActionMap,
             createConfigDelegate: getCreateConfigDelegateThunk({
                 getContentSourceDataById: () => this.contentSourceDataById,
                 logger: this.userLogger
@@ -1278,6 +1285,7 @@ export class ContentStore {
                 modelMap: modelMap,
                 defaultLocaleCode: csData.defaultLocaleCode,
                 assetSources: this.stackbitConfig?.assetSources ?? [],
+                customActionMap: this.customActionMap,
                 createConfigDelegate: getCreateConfigDelegateThunk({
                     getContentSourceDataById: () => this.contentSourceDataById,
                     logger: this.userLogger
@@ -1326,9 +1334,10 @@ export class ContentStore {
                 const contentSourceType = contentSourceData.instance.getContentSourceType();
                 const srcProjectId = contentSourceData.instance.getProjectId();
                 const filteredModels = _.omitBy(contentSourceData.modelMap, (model) => model.name === StackbitPresetModelName);
+                const mappedModels = stripModelActions({ modelMap: filteredModels });
                 // if `projectId` is number (even as string) e.g., '1234', _.set() will create an array of length 1235 and insert the item at the end.
                 // _.setWith(..., Object) ensures the values are always created as object keys, not as array indexes.
-                _.setWith(result, [contentSourceType, srcProjectId], filteredModels, Object);
+                _.setWith(result, [contentSourceType, srcProjectId], mappedModels, Object);
                 _.setWith(result, [contentSourceType, srcProjectId, '__image_model'], IMAGE_MODEL, Object);
                 return result;
             },
@@ -1351,6 +1360,56 @@ export class ContentStore {
         );
     }
 
+    async getGlobalActions({
+        pageUrl,
+        user,
+        locale,
+        currentPageDocument
+    }: {
+        pageUrl?: string;
+        user?: ContentStoreTypes.User;
+        locale?: string;
+        currentPageDocument?: ContentStoreTypes.APICustomActionDocumentSpecifier;
+    }): Promise<(ContentStoreTypes.APICustomActionGlobal | ContentStoreTypes.APICustomActionBulk)[]> {
+        return getGlobalAndBulkAPIActions({
+            stackbitConfig: this.stackbitConfig,
+            customActionMap: this.customActionMap,
+            contentSourceDataById: this.contentSourceDataById,
+            userLogger: this.userLogger,
+            locale,
+            pageUrl,
+            user,
+            currentPageDocument
+        });
+    }
+
+    async getCustomActions(getActionRequest: ContentStoreTypes.APIGetCustomActionRequest): Promise<ContentStoreTypes.APICustomAction[]> {
+        return resolveCustomActionsById({
+            getActionRequest,
+            customActionMap: this.customActionMap,
+            contentSourceDataById: this.contentSourceDataById,
+            userLogger: this.userLogger
+        });
+    }
+
+    async runCustomAction(runActionRequest: ContentStoreTypes.APIRunCustomActionRequest): Promise<void> {
+        this.onActionStateChangeCallback({
+            actionId: runActionRequest.actionId,
+            actionName: runActionRequest.actionName,
+            actionType: runActionRequest.actionType,
+            state: 'running'
+        });
+        runCustomAction({
+            runActionRequest: runActionRequest,
+            contentSourceDataById: this.contentSourceDataById,
+            customActionMap: this.customActionMap,
+            userLogger: this.userLogger,
+            stackbitConfig: this.stackbitConfig
+        }).then((actionStateChange) => {
+            this.onActionStateChangeCallback(actionStateChange);
+        });
+    }
+
     getPresets({ locale }: { locale?: string } = {}): Record<string, any> {
         if (!this.presets || !locale) {
             return this.presets ?? {};
@@ -2560,11 +2619,7 @@ export class ContentStore {
     }
 
     private getContentSourceDataByIdOrThrow(contentSourceId: string): ContentSourceData {
-        const contentSourceData = this.contentSourceDataById[contentSourceId];
-        if (!contentSourceData) {
-            throw new Error(`Connection failed for content source: '${contentSourceId}'.`);
-        }
-        return contentSourceData;
+        return getContentSourceDataByIdOrThrow(contentSourceId, this.contentSourceDataById);
     }
 
     onWebhook({ srcType, srcProjectId, data, headers }: { srcType: string; srcProjectId: string; data: unknown; headers: Record<string, string> }) {

package/src/index.ts

@@ -9,5 +9,4 @@ export * from './content-store';
 export * as ContentStoreTypes from './types';
 export { default as encodeData } from './encoder';
 export * from './encoder';
-export * from './types/search-filter';
 export * from './services';