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

package/dist/utils/tree-views.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSanitizedTreeViews = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const content_store_utils_1 = require("../content-store-utils");
+async function getSanitizedTreeViews({ configDelegate, stackbitConfig, contentSourceDataById, logger }) {
+    var _a, _b;
+    const treeViews = (_b = (await ((_a = stackbitConfig === null || stackbitConfig === void 0 ? void 0 : stackbitConfig.treeViews) === null || _a === void 0 ? void 0 : _a.call(stackbitConfig, configDelegate)))) !== null && _b !== void 0 ? _b : [];
+    const mapTreeViews = (treeViews) => treeViews
+        .map((treeView) => {
+        var _a, _b, _c, _d, _e, _f;
+        if ('document' in treeView && treeView.document) {
+            const contentSourceId = (0, content_store_utils_1.getContentSourceId)(treeView.document.srcType, treeView.document.srcProjectId);
+            const document = (_a = contentSourceDataById[contentSourceId]) === null || _a === void 0 ? void 0 : _a.documentMap[treeView.document.id];
+            // explicit check because developers can skip TS check and just not define required properties of document object
+            if (document) {
+                treeView = {
+                    ...treeView,
+                    stableId: (_b = treeView.stableId) !== null && _b !== void 0 ? _b : document.srcObjectId,
+                    label: (_c = treeView.label) !== null && _c !== void 0 ? _c : document.getPreview({ delegate: configDelegate }).previewTitle,
+                    document: {
+                        srcType: treeView.document.srcType,
+                        srcProjectId: treeView.document.srcProjectId,
+                        id: treeView.document.id
+                    }
+                };
+            }
+            else {
+                logger.warn(`One of required properties is missing in tree view document, document skipped from tree view,
+                            srcType: ${(_d = treeView.document) === null || _d === void 0 ? void 0 : _d.srcType}, srcProjectId: ${(_e = treeView.document) === null || _e === void 0 ? void 0 : _e.srcProjectId}, id: ${(_f = treeView.document) === null || _f === void 0 ? void 0 : _f.id}.`);
+                // don't early return because treeView.children can be defined properly
+                if (treeView.children) {
+                    treeView = lodash_1.default.omit(treeView, 'document');
+                }
+                else {
+                    return undefined;
+                }
+            }
+        }
+        if ('children' in treeView && treeView.children) {
+            // required check because of
+            // 1. typecast during omit in previous if
+            // 2. developer can ignore TS check and just not define stableId and label
+            if (treeView.stableId && treeView.label) {
+                treeView = {
+                    ...treeView,
+                    children: mapTreeViews(treeView.children)
+                };
+            }
+            else {
+                logger.warn('one of required properties (stableId or label) is missing in tree view, children are skipped from tree view');
+                return undefined;
+            }
+        }
+        return treeView;
+    })
+        .filter(Boolean);
+    return mapTreeViews(treeViews);
+}
+exports.getSanitizedTreeViews = getSanitizedTreeViews;
+//# sourceMappingURL=tree-views.js.map

package/dist/utils/tree-views.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-views.js","sourceRoot":"","sources":["../../src/utils/tree-views.ts"],"names":[],"mappings":";;;;;;AAAA,oDAAuB;AAIvB,gEAA4D;AAErD,KAAK,UAAU,qBAAqB,CAAC,EACxC,cAAc,EACd,cAAc,EACd,qBAAqB,EACrB,MAAM,EAMT;;IACG,MAAM,SAAS,GAAG,MAAA,CAAC,MAAM,CAAA,MAAA,cAAc,aAAd,cAAc,uBAAd,cAAc,CAAE,SAAS,+CAAzB,cAAc,EAAc,cAAc,CAAC,CAAA,CAAC,mCAAI,EAAE,CAAC;IAE5E,MAAM,YAAY,GAAG,CAAC,SAAkC,EAA2B,EAAE,CACjF,SAAS;SACJ,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;;QACd,IAAI,UAAU,IAAI,QAAQ,IAAI,QAAQ,CAAC,QAAQ,EAAE;YAC7C,MAAM,eAAe,GAAG,IAAA,wCAAkB,EAAC,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;YACtG,MAAM,QAAQ,GAAG,MAAA,qBAAqB,CAAC,eAAe,CAAC,0CAAE,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;YAE3F,iHAAiH;YACjH,IAAI,QAAQ,EAAE;gBACV,QAAQ,GAAG;oBACP,GAAG,QAAQ;oBACX,QAAQ,EAAE,MAAA,QAAQ,CAAC,QAAQ,mCAAI,QAAQ,CAAC,WAAW;oBACnD,KAAK,EAAE,MAAA,QAAQ,CAAC,KAAK,mCAAI,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC,CAAC,YAAY;oBACvF,QAAQ,EAAE;wBACN,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO;wBAClC,YAAY,EAAE,QAAQ,CAAC,QAAQ,CAAC,YAAY;wBAC5C,EAAE,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE;qBAC3B;iBACJ,CAAC;aACL;iBAAM;gBACH,MAAM,CAAC,IAAI,CACP;uCACW,MAAA,QAAQ,CAAC,QAAQ,0CAAE,OAAO,mBAAmB,MAAA,QAAQ,CAAC,QAAQ,0CAAE,YAAY,SAAS,MAAA,QAAQ,CAAC,QAAQ,0CAAE,EAAE,GAAG,CAC3H,CAAC;gBACF,uEAAuE;gBACvE,IAAI,QAAQ,CAAC,QAAQ,EAAE;oBACnB,QAAQ,GAAG,gBAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAA8B,CAAC;iBACxE;qBAAM;oBACH,OAAO,SAAS,CAAC;iBACpB;aACJ;SACJ;QAED,IAAI,UAAU,IAAI,QAAQ,IAAI,QAAQ,CAAC,QAAQ,EAAE;YAC7C,4BAA4B;YAC5B,yCAAyC;YACzC,0EAA0E;YAC1E,IAAI,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,KAAK,EAAE;gBACrC,QAAQ,GAAG;oBACP,GAAG,QAAQ;oBACX,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC;iBAC5C,CAAC;aACL;iBAAM;gBACH,MAAM,CAAC,IAAI,CAAC,6GAA6G,CAAC,CAAC;gBAC3H,OAAO,SAAS,CAAC;aACpB;SACJ;QACD,OAAO,QAAQ,CAAC;IACpB,CAAC,CAAC;SACD,MAAM,CAAC,OAAO,CAA4B,CAAC;IAEpD,OAAO,YAAY,CAAC,SAAS,CAAC,CAAC;AACnC,CAAC;AAjED,sDAiEC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackbit/cms-core",
-  "version": "0.7.6-develop.1",
+  "version": "0.8.0-develop.0",
   "description": "stackbit-dev",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,9 +25,9 @@
     "@babel/parser": "^7.11.5",
     "@babel/traverse": "^7.11.5",
     "@iarna/toml": "^2.2.3",
-    "@stackbit/sdk": "0.6.6-develop.1",
-    "@stackbit/types": "0.8.6-develop.1",
-    "@stackbit/utils": "0.2.43-develop.1",
+    "@stackbit/sdk": "0.7.0-develop.0",
+    "@stackbit/types": "0.9.0-develop.0",
+    "@stackbit/utils": "0.3.0-develop.0",
     "chalk": "^4.0.1",
     "esm": "^3.2.25",
     "fs-extra": "^8.1.0",
@@ -42,5 +42,5 @@
     "slugify": "^1.6.5",
     "uuid": "^9.0.0"
   },
-  "gitHead": "d09511dcd6d38ce30e32dfa371a530fdd4bb64c9"
+  "gitHead": "817724f480726a53c0b2708a23d5c752965a87b4"
 }

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,
@@ -67,6 +69,7 @@ import {
     logUploadAssets,
     pluralize
 } from './utils/user-log-utils';
+import { getSanitizedTreeViews } from './utils/tree-views';
 
 export type HandleConfigAssets = <T extends Model>({ models, presets }: { models?: T[]; presets?: PresetMap }) => Promise<{ models: T[]; presets: PresetMap }>;
 
@@ -81,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;
 }
@@ -126,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[] = [];
@@ -140,6 +145,8 @@ export class ContentStore {
     private siteMapEntryGroups: SiteMapEntryGroups = {};
     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' });
@@ -152,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;
@@ -461,8 +469,20 @@ export class ContentStore {
             contentSourceRawDataArr: contentSourceRawDataArr
         });
 
+        const configDelegate = createConfigDelegate({
+            contentSourceDataById: this.contentSourceDataById,
+            logger: this.userLogger
+        });
+
         // generate create site map entries
         this.siteMapEntryGroups = await getSiteMapEntriesFromStackbitConfig({
+            stackbitConfig: this.stackbitConfig,
+            contentSourceDataById: this.contentSourceDataById,
+            configDelegate
+        });
+
+        this.treeViews = await getSanitizedTreeViews({
+            configDelegate,
             stackbitConfig: this.stackbitConfig,
             contentSourceDataById: this.contentSourceDataById,
             logger: this.userLogger
@@ -543,12 +563,22 @@ export class ContentStore {
             });
         } else {
             this.logger.debug('processContentStoreEvents => content changes', { ...contentChangeResultCounts(contentChanges), presetsUpdated });
+            const configDelegate = createConfigDelegate({
+                contentSourceDataById: this.contentSourceDataById,
+                logger: this.userLogger
+            });
             // If the schema wasn't changed, update SiteMapEntries with the changed content.
             this.siteMapEntryGroups = await updateSiteMapEntriesWithContentChanges({
                 siteMapEntryGroups: this.siteMapEntryGroups,
                 contentChanges: contentChanges,
                 stackbitConfig: this.stackbitConfig,
                 contentSourceDataById: this.contentSourceDataById,
+                configDelegate
+            });
+            this.treeViews = await getSanitizedTreeViews({
+                configDelegate,
+                stackbitConfig: this.stackbitConfig,
+                contentSourceDataById: this.contentSourceDataById,
                 logger: this.userLogger
             });
             // If presets were updated, call onSchemaChangeCallback to notify the Studio.
@@ -1016,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
@@ -1254,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
@@ -1302,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;
             },
@@ -1327,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 ?? {};
@@ -1474,6 +1557,10 @@ export class ContentStore {
         return _.isEmpty(locale) ? siteMapEntries : siteMapEntries.filter((siteMapEntry) => !siteMapEntry.locale || siteMapEntry.locale === locale);
     }
 
+    getTreeViews(): CSITypes.TreeViewNode[] {
+        return this.treeViews;
+    }
+
     getSiteMapEntriesForDocument({
         srcType,
         srcProjectId,
@@ -2532,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';