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

package/src/content-store.ts

@@ -59,7 +59,7 @@ import { mapAssetsToLocalizedApiImages, mapDocumentsToLocalizedApiObjects, mapSt
 import { mapDocumentsToApiDocuments } from './utils/store-to-api-v2-docs-converter';
 import { convertOperationField, createDocumentRecursively, CreateDocumentThunk, getCreateDocumentThunk } from './utils/create-update-csi-docs';
 import { mergeObjectWithDocument } from './utils/duplicate-document';
-import { normalizeModels, validateModels } from './utils/model-utils';
+import { getModelMap, normalizeModels, validateModels } from './utils/model-utils';
 import { IMAGE_MODEL } from './common/common-schema';
 import { getDocumentObjectFromPreset, getPresetFromDocument } from './utils/preset-utils';
 import { BackCompatContentSourceInterface, backwardCompatibleContentSource } from './utils/backward-compatibility';
@@ -68,7 +68,7 @@ import { GitService } from './services';
 import { getAssetSourcesForClient } from './utils/asset-sources-utils';
 import { deleteDocumentHooked, publishDocumentHooked, updateDocumentHooked } from './utils/document-hooks';
 import { resolveCustomActionsById, getGlobalAndBulkAPIActions, runCustomAction } from './utils/custom-actions';
-import { getSanitizedTreeViews } from './utils/tree-views';
+import { getSanitizedTreeViews, removeHiddenTreeViews } from './utils/tree-views';
 import { getModelFieldAtFieldPath } from './utils/field-path-utils';
 import {
     logCreateDocument,
@@ -82,6 +82,8 @@ import {
 import { ContentEngine, PluginRef, contentEngine } from 'content-engine';
 import { mapDocumentVersionsToApiDocumentVersions } from './utils/csi-to-api-docs-converter';
 import { NoopFileCache, FileCache } from './utils/file-cache';
+import { getContentSourceFilteredModelsForUser, getFilteredAssetsForUser, getFilteredDocumentsForUser } from './utils/filtered-entities';
+import { STACKBIT_PRESET_MODEL_NAME } from './consts';
 
 export type HandleConfigAssets = <T extends Model>({ models, presets }: { models?: T[]; presets?: PresetMap }) => Promise<{ models: T[]; presets: PresetMap }>;
 
@@ -129,8 +131,6 @@ type ContentStoreEvent =
           contentChanges: CSITypes.ContentChanges;
       };
 
-export const StackbitPresetModelName = 'stackbitPreset';
-
 export class ContentStore {
     private readonly logger: CSITypes.Logger;
     private readonly userLogger: CSITypes.Logger;
@@ -389,7 +389,7 @@ export class ContentStore {
         const presets = _.reduce(
             contentSourceData.csiDocuments,
             (result: Record<string, Preset>, csiDocument) => {
-                if (csiDocument.modelName === StackbitPresetModelName) {
+                if (csiDocument.modelName === STACKBIT_PRESET_MODEL_NAME) {
                     const preset = getPresetFromDocument({
                         srcType: contentSourceData.srcType,
                         srcProjectId: contentSourceData.srcProjectId,
@@ -511,7 +511,7 @@ export class ContentStore {
         // find first content source that supports presets
         for (let i = 0; i < contentSources.length; i++) {
             const contentSourceDataRaw = contentSourceRawDataArr[i];
-            if (contentSourceDataRaw?.csiModelMap?.[StackbitPresetModelName]) {
+            if (contentSourceDataRaw?.csiModelMap?.[STACKBIT_PRESET_MODEL_NAME]) {
                 this.presetsContentSource = contentSourceDataRaw.instance;
                 // reload presets from content source only if needed
                 if (init || !contentSourceIds || contentSourceIds.includes(contentSourceDataRaw.id)) {
@@ -1064,7 +1064,7 @@ export class ContentStore {
         contentChangesFull.deletedDocumentIds.forEach((docId) => {
             // remove preset, make sure there is something to remove first because
             // were explicitly calling onContentChange from deletePreset as well
-            if (this.presets[docId] && contentSourceData.csiDocumentMap[docId]?.modelName === StackbitPresetModelName) {
+            if (this.presets[docId] && contentSourceData.csiDocumentMap[docId]?.modelName === STACKBIT_PRESET_MODEL_NAME) {
                 presetsUpdated = true;
                 const preset = this.presets[docId]!;
                 const model = contentSourceData.modelMap[preset.modelName];
@@ -1194,7 +1194,7 @@ export class ContentStore {
                 contentSourceData.documents.splice(dataIndex, 1, document);
                 contentSourceData.csiDocuments.splice(dataIndex, 1, csiDocument);
             }
-            if (csiDocument.modelName === StackbitPresetModelName) {
+            if (csiDocument.modelName === STACKBIT_PRESET_MODEL_NAME) {
                 presetsUpdated = true;
                 const preset = getPresetFromDocument({
                     srcType: contentSourceData.srcType,
@@ -1461,17 +1461,32 @@ export class ContentStore {
         return getAssetSourcesForClient(this.stackbitConfig);
     }
 
-    getModels(): Record<string, Record<string, Record<string, Model | ImageModel>>> {
+    getModels({ user }: { user?: ContentStoreTypes.User } = {}): Record<string, Record<string, Record<string, Model | ImageModel>>> {
+        const configDelegate = createConfigDelegate({
+            contentSourceDataById: this.contentSourceDataById,
+            logger: this.userLogger
+        });
         return _.reduce(
             this.contentSourceDataById,
             (result: Record<string, Record<string, Record<string, Model | ImageModel>>>, contentSourceData) => {
                 const contentSourceType = contentSourceData.instance.getContentSourceType();
                 const srcProjectId = contentSourceData.instance.getProjectId();
-                const filteredModels = _.omitBy(contentSourceData.modelMap, (model) => model.name === StackbitPresetModelName);
+
+                const filteredModels = getContentSourceFilteredModelsForUser({
+                    user,
+                    configDelegate,
+                    contentSourceData,
+                    filterModel: this.stackbitConfig?.filterModel
+                });
+
+                const modelsMap = getModelMap({ models: 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], modelsMap, Object);
                 _.setWith(result, [contentSourceType, srcProjectId, '__image_model'], IMAGE_MODEL, Object);
+
                 return result;
             },
             {}
@@ -1661,13 +1676,45 @@ export class ContentStore {
         };
     }
 
-    getSiteMapEntries({ locale }: { locale?: string } = {}): CSITypes.SiteMapEntry[] {
+    getSiteMapEntries({ locale, user }: { locale?: string; user?: ContentStoreTypes.User } = {}): CSITypes.SiteMapEntry[] {
         const siteMapEntries = _.reduce(
             this.siteMapEntryGroups,
             (accum: CSITypes.SiteMapEntry[], siteMapEntryGroup) => {
                 return _.reduce(
                     siteMapEntryGroup,
                     (accum: CSITypes.SiteMapEntry[], siteMapEntry) => {
+                        if (!_.isEmpty(locale)) {
+                            // filter out in wrong locale
+                            if (siteMapEntry.locale && siteMapEntry.locale !== locale) {
+                                return accum;
+                            }
+                        }
+                        if ('document' in siteMapEntry) {
+                            // check for hidden documents
+                            const contentSourceId = getContentSourceId(siteMapEntry.document.srcType, siteMapEntry.document.srcProjectId);
+                            const document = getContentSourceDataByIdOrThrow(contentSourceId, this.contentSourceDataById)?.documentMap[
+                                siteMapEntry.document.id
+                            ];
+                            if (document) {
+                                const [filteredDocument] = getFilteredDocumentsForUser({
+                                    user,
+                                    documents: [document],
+                                    filterModel: this.stackbitConfig?.filterModel,
+                                    filterDocument: this.stackbitConfig?.filterDocument,
+                                    contentSourceDataById: this.contentSourceDataById,
+                                    assetSources: this.stackbitConfig?.assetSources ?? [],
+                                    createConfigDelegate: getCreateConfigDelegateThunk({
+                                        getContentSourceDataById: () => this.contentSourceDataById,
+                                        logger: this.userLogger
+                                    }),
+                                    logger: this.userLogger,
+                                    customActionRunStateMap: this.customActionRunStateMap
+                                });
+                                if (filteredDocument && filteredDocument.hidden) {
+                                    return accum;
+                                }
+                            }
+                        }
                         if (!siteMapEntry.label) {
                             const fieldLabelValue = getDocumentFieldLabelValueForSiteMapEntry({
                                 siteMapEntry,
@@ -1688,11 +1735,51 @@ export class ContentStore {
             []
         );
 
-        return _.isEmpty(locale) ? siteMapEntries : siteMapEntries.filter((siteMapEntry) => !siteMapEntry.locale || siteMapEntry.locale === locale);
+        if (user && this.stackbitConfig?.transformSitemap) {
+            const configDelegate = createConfigDelegate({
+                contentSourceDataById: this.contentSourceDataById,
+                logger: this.userLogger
+            });
+            return this.stackbitConfig.transformSitemap({ ...configDelegate, sitemap: _.cloneDeep(siteMapEntries), userContext: user });
+        }
+
+        return siteMapEntries;
     }
 
-    getTreeViews(): CSITypes.TreeViewNode[] {
-        return this.treeViews;
+    getTreeViews({ user }: { user?: ContentStoreTypes.User } = {}): CSITypes.TreeViewNode[] {
+        let treeViews = this.treeViews;
+        if (this.stackbitConfig?.transformTreeViews && user) {
+            const configDelegate = createConfigDelegate({
+                contentSourceDataById: this.contentSourceDataById,
+                logger: this.userLogger
+            });
+            treeViews = this.stackbitConfig.transformTreeViews({ ...configDelegate, treeViews: _.cloneDeep(treeViews), userContext: user });
+        }
+        return removeHiddenTreeViews({
+            treeViews,
+            getDocumentForUser: (opts) => {
+                const contentSourceId = getContentSourceId(opts.srcType, opts.srcProjectId);
+                const document = getContentSourceDataByIdOrThrow(contentSourceId, this.contentSourceDataById)?.documentMap[opts.srcDocumentId];
+                if (!document || !user) {
+                    return document;
+                }
+                const [filteredDocument] = getFilteredDocumentsForUser({
+                    user,
+                    documents: [document],
+                    filterModel: this.stackbitConfig?.filterModel,
+                    filterDocument: this.stackbitConfig?.filterDocument,
+                    contentSourceDataById: this.contentSourceDataById,
+                    assetSources: this.stackbitConfig?.assetSources ?? [],
+                    createConfigDelegate: getCreateConfigDelegateThunk({
+                        getContentSourceDataById: () => this.contentSourceDataById,
+                        logger: this.userLogger
+                    }),
+                    logger: this.userLogger,
+                    customActionRunStateMap: this.customActionRunStateMap
+                });
+                return filteredDocument;
+            }
+        });
     }
 
     getSiteMapEntriesForDocument({
@@ -1719,15 +1806,35 @@ export class ContentStore {
     getDocument({
         srcDocumentId,
         srcProjectId,
-        srcType
+        srcType,
+        user
     }: {
         srcDocumentId: string;
         srcProjectId: string;
         srcType: string;
+        user?: ContentStoreTypes.User;
     }): ContentStoreTypes.Document | undefined {
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-        return contentSourceData.documentMap[srcDocumentId];
+        const document = contentSourceData.documentMap[srcDocumentId];
+        if (!document) {
+            return document;
+        }
+        const [filteredDocument] = getFilteredDocumentsForUser({
+            user,
+            documents: [document],
+            filterModel: this.stackbitConfig?.filterModel,
+            filterDocument: this.stackbitConfig?.filterDocument,
+            contentSourceDataById: this.contentSourceDataById,
+            assetSources: this.stackbitConfig?.assetSources ?? [],
+            createConfigDelegate: getCreateConfigDelegateThunk({
+                getContentSourceDataById: () => this.contentSourceDataById,
+                logger: this.userLogger
+            }),
+            logger: this.userLogger,
+            customActionRunStateMap: this.customActionRunStateMap
+        });
+        return filteredDocument ?? document;
     }
 
     getDocumentsByContext({ context, srcProjectId, srcType }: { context: any; srcProjectId?: string; srcType: string }): ContentStoreTypes.Document[] {
@@ -1748,21 +1855,36 @@ export class ContentStore {
         );
     }
 
-    getDocuments({ locale }: { locale?: string } = {}): ContentStoreTypes.Document[] {
-        return _.reduce(
+    getDocuments({ locale, user }: { locale?: string; user?: ContentStoreTypes.User } = {}): ContentStoreTypes.Document[] {
+        const documents = _.reduce(
             this.contentSourceDataById,
             (documents: ContentStoreTypes.Document[], contentSourceData) => {
                 const currentDocuments = _.isEmpty(locale)
                     ? contentSourceData.documents
                     : contentSourceData.documents.filter((document) => !document.locale || document.locale === locale);
-                const filteredDocuments = currentDocuments.filter((document) => document.srcModelName !== StackbitPresetModelName);
+                const filteredDocuments = currentDocuments.filter((document) => document.srcModelName !== STACKBIT_PRESET_MODEL_NAME);
                 return documents.concat(filteredDocuments);
             },
             []
         );
+        const filteredDocuments = getFilteredDocumentsForUser({
+            user,
+            documents,
+            filterModel: this.stackbitConfig?.filterModel,
+            filterDocument: this.stackbitConfig?.filterDocument,
+            contentSourceDataById: this.contentSourceDataById,
+            assetSources: this.stackbitConfig?.assetSources ?? [],
+            createConfigDelegate: getCreateConfigDelegateThunk({
+                getContentSourceDataById: () => this.contentSourceDataById,
+                logger: this.userLogger
+            }),
+            logger: this.userLogger,
+            customActionRunStateMap: this.customActionRunStateMap
+        });
+        return filteredDocuments;
     }
 
-    getApiDocuments({ documentSpecs }: { documentSpecs?: DocumentSpecifier[] } = {}): {
+    getApiDocuments({ documentSpecs, user }: { documentSpecs?: DocumentSpecifier[]; user?: ContentStoreTypes.User } = {}): {
         documents: ContentStoreTypes.APIDocument[];
     } {
         let filteredDocuments: ContentStoreTypes.Document[];
@@ -1771,7 +1893,7 @@ export class ContentStore {
             filteredDocuments = documentSpecs?.reduce((acc: ContentStoreTypes.Document[], docSpec) => {
                 const contentSourceId = getContentSourceId(docSpec.srcType, docSpec.srcProjectId);
                 const document = this.contentSourceDataById[contentSourceId]?.documentMap[docSpec.srcDocumentId];
-                if (document && document.srcModelName !== StackbitPresetModelName) {
+                if (document && document.srcModelName !== STACKBIT_PRESET_MODEL_NAME) {
                     acc.push(document);
                 }
                 return acc;
@@ -1781,12 +1903,27 @@ export class ContentStore {
             filteredDocuments = _.reduce(
                 this.contentSourceDataById,
                 (accDocuments: ContentStoreTypes.Document[], contentSourceData) => {
-                    return accDocuments.concat(contentSourceData.documents.filter((document) => document.srcModelName !== StackbitPresetModelName));
+                    return accDocuments.concat(contentSourceData.documents.filter((document) => document.srcModelName !== STACKBIT_PRESET_MODEL_NAME));
                 },
                 []
             );
         }
 
+        filteredDocuments = getFilteredDocumentsForUser({
+            user,
+            documents: filteredDocuments,
+            filterModel: this.stackbitConfig?.filterModel,
+            filterDocument: this.stackbitConfig?.filterDocument,
+            contentSourceDataById: this.contentSourceDataById,
+            assetSources: this.stackbitConfig?.assetSources ?? [],
+            createConfigDelegate: getCreateConfigDelegateThunk({
+                getContentSourceDataById: () => this.contentSourceDataById,
+                logger: this.userLogger
+            }),
+            logger: this.userLogger,
+            customActionRunStateMap: this.customActionRunStateMap
+        });
+
         return {
             documents: mapDocumentsToApiDocuments({
                 documents: filteredDocuments,
@@ -1802,8 +1939,8 @@ export class ContentStore {
         return contentSourceData.assetMap[srcAssetId];
     }
 
-    getAssets({ locale }: { locale?: string }): ContentStoreTypes.Asset[] {
-        return _.reduce(
+    getAssets({ locale, user }: { locale?: string; user?: ContentStoreTypes.User } = {}): ContentStoreTypes.Asset[] {
+        const assets = _.reduce(
             this.contentSourceDataById,
             (assets: ContentStoreTypes.Asset[], contentSourceData) => {
                 const currentAssets = _.isEmpty(locale)
@@ -1813,9 +1950,25 @@ export class ContentStore {
             },
             []
         );
+        const filteredAssets = getFilteredAssetsForUser({
+            user,
+            assets,
+            filterAsset: this.stackbitConfig?.filterAsset,
+            contentSourceDataById: this.contentSourceDataById,
+            configDelegate: createConfigDelegate({ contentSourceDataById: this.contentSourceDataById, logger: this.userLogger })
+        });
+        return filteredAssets;
     }
 
-    getLocalizedApiObjects({ locale, objectIds }: { locale?: string; objectIds?: string[] }): ContentStoreTypes.APIObject[] {
+    getLocalizedApiObjects({
+        locale,
+        objectIds,
+        user
+    }: {
+        locale?: string;
+        objectIds?: string[];
+        user?: ContentStoreTypes.User;
+    }): ContentStoreTypes.APIObject[] {
         const hasExplicitLocale = !_.isEmpty(locale);
         return _.reduce(
             this.contentSourceDataById,
@@ -1824,10 +1977,36 @@ export class ContentStore {
                     ? contentSourceData.documents.filter((document) => objectIds.includes(document.srcObjectId))
                     : contentSourceData.documents;
                 documents = hasExplicitLocale ? documents.filter((document) => !document.locale || document.locale === locale) : documents;
+
                 let assets = objectIds ? contentSourceData.assets.filter((asset) => objectIds.includes(asset.srcObjectId)) : contentSourceData.assets;
                 assets = hasExplicitLocale ? assets.filter((asset) => !asset.locale || asset.locale === locale) : assets;
+
                 const currentLocale = locale ?? contentSourceData.defaultLocaleCode;
-                const filteredDocuments = documents.filter((document) => document.srcModelName !== StackbitPresetModelName);
+                let filteredDocuments = documents.filter((document) => document.srcModelName !== STACKBIT_PRESET_MODEL_NAME);
+
+                filteredDocuments = getFilteredDocumentsForUser({
+                    user,
+                    documents: filteredDocuments,
+                    filterModel: this.stackbitConfig?.filterModel,
+                    filterDocument: this.stackbitConfig?.filterDocument,
+                    contentSourceDataById: this.contentSourceDataById,
+                    assetSources: this.stackbitConfig?.assetSources ?? [],
+                    createConfigDelegate: getCreateConfigDelegateThunk({
+                        getContentSourceDataById: () => this.contentSourceDataById,
+                        logger: this.userLogger
+                    }),
+                    logger: this.userLogger,
+                    customActionRunStateMap: this.customActionRunStateMap
+                });
+
+                assets = getFilteredAssetsForUser({
+                    user,
+                    assets,
+                    filterAsset: this.stackbitConfig?.filterAsset,
+                    contentSourceDataById: this.contentSourceDataById,
+                    configDelegate: createConfigDelegate({ contentSourceDataById: this.contentSourceDataById, logger: this.userLogger })
+                });
+
                 const documentObjects = mapDocumentsToLocalizedApiObjects({
                     documents: filteredDocuments,
                     locale: currentLocale,
@@ -1845,8 +2024,9 @@ export class ContentStore {
         srcProjectId,
         pageSize = 20,
         pageNum = 1,
-        searchQuery
-    }: { srcType?: string; srcProjectId?: string; pageSize?: number; pageNum?: number; searchQuery?: string } = {}): {
+        searchQuery,
+        user
+    }: { srcType?: string; srcProjectId?: string; pageSize?: number; pageNum?: number; searchQuery?: string; user?: ContentStoreTypes.User } = {}): {
         assets: ContentStoreTypes.APIAsset[];
         pageSize: number;
         pageNum: number;
@@ -1856,12 +2036,26 @@ export class ContentStore {
         if (srcProjectId && srcType) {
             const contentSourceId = getContentSourceId(srcType, srcProjectId);
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-            assets = mapStoreAssetsToAPIAssets(contentSourceData.assets, this.staticAssetsPublicPath, contentSourceData.defaultLocaleCode);
+            const filteredAssets = getFilteredAssetsForUser({
+                user,
+                assets: contentSourceData.assets,
+                filterAsset: this.stackbitConfig?.filterAsset,
+                contentSourceDataById: this.contentSourceDataById,
+                configDelegate: createConfigDelegate({ contentSourceDataById: this.contentSourceDataById, logger: this.userLogger })
+            });
+            assets = mapStoreAssetsToAPIAssets(filteredAssets, this.staticAssetsPublicPath, contentSourceData.defaultLocaleCode);
         } else {
             assets = _.reduce(
                 this.contentSourceDataById,
                 (result: ContentStoreTypes.APIAsset[], contentSourceData) => {
-                    const assets = mapStoreAssetsToAPIAssets(contentSourceData.assets, this.staticAssetsPublicPath, contentSourceData.defaultLocaleCode);
+                    const filteredAssets = getFilteredAssetsForUser({
+                        user,
+                        assets: contentSourceData.assets,
+                        filterAsset: this.stackbitConfig?.filterAsset,
+                        contentSourceDataById: this.contentSourceDataById,
+                        configDelegate: createConfigDelegate({ contentSourceDataById: this.contentSourceDataById, logger: this.userLogger })
+                    });
+                    const assets = mapStoreAssetsToAPIAssets(filteredAssets, this.staticAssetsPublicPath, contentSourceData.defaultLocaleCode);
                     return result.concat(assets);
                 },
                 []
@@ -2051,9 +2245,9 @@ export class ContentStore {
         const document = await this.createDocument({
             srcType: this.presetsContentSource.getContentSourceType(),
             srcProjectId: this.presetsContentSource.getProjectId(),
-            modelName: StackbitPresetModelName,
+            modelName: STACKBIT_PRESET_MODEL_NAME,
             object: {
-                ...getDocumentObjectFromPreset(preset, contentSourceData.modelMap[StackbitPresetModelName]),
+                ...getDocumentObjectFromPreset(preset, contentSourceData.modelMap[STACKBIT_PRESET_MODEL_NAME]),
                 thumbnail
             },
             user
@@ -2720,11 +2914,13 @@ export class ContentStore {
             modelName: string;
         }>;
         locale?: string;
+        user?: ContentStoreTypes.User;
     }): Promise<{
         total: number;
         items: ContentStoreTypes.Document[];
     }> {
         this.logger.debug('searchDocuments');
+
         const locale = data.locale;
         const objectsBySourceId = _.groupBy(data.models, (object) => getContentSourceId(object.srcType, object.srcProjectId));
         const contentSourceIds = Object.keys(objectsBySourceId);
@@ -2742,9 +2938,28 @@ export class ContentStore {
                 ? contentSourceData.documents
                 : contentSourceData.documents.filter((document) => !document.locale || document.locale === locale);
             const contentSourceScheduledActions = contentSourceData.scheduledActions;
-            const filteredDocuments = contentSourceDocuments.filter((document) => document.srcModelName !== StackbitPresetModelName);
-            documents.push(...filteredDocuments);
+            const filteredDocuments = contentSourceDocuments.filter((document) => document.srcModelName !== STACKBIT_PRESET_MODEL_NAME);
+            const userDocuments = getFilteredDocumentsForUser({
+                user: data.user,
+                documents: filteredDocuments,
+                filterModel: this.stackbitConfig?.filterModel,
+                filterDocument: this.stackbitConfig?.filterDocument,
+                contentSourceDataById: this.contentSourceDataById,
+                assetSources: this.stackbitConfig?.assetSources ?? [],
+                createConfigDelegate: getCreateConfigDelegateThunk({
+                    getContentSourceDataById: () => this.contentSourceDataById,
+                    logger: this.userLogger
+                }),
+                logger: this.userLogger,
+                customActionRunStateMap: this.customActionRunStateMap
+            });
+
+            // filter out hidden documents from the search
+            const visibleDocuments = userDocuments.filter((document) => !document.hidden);
+
+            documents.push(...visibleDocuments);
             scheduledActions.push(...contentSourceScheduledActions);
+
             if (contentSourceData.defaultLocaleCode) {
                 defaultLocales[contentSourceId] = contentSourceData.defaultLocaleCode;
             }
@@ -2764,12 +2979,14 @@ export class ContentStore {
         srcType,
         srcProjectId,
         documentId,
-        locale
+        locale,
+        user
     }: {
         srcType: string;
         srcProjectId: string;
         documentId: string;
         locale?: string;
+        user?: ContentStoreTypes.User;
     }): Promise<{ versions: ContentStoreTypes.APIDocumentVersion[] }> {
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
@@ -2787,6 +3004,15 @@ export class ContentStore {
         }
 
         const { versions } = await contentSourceData.instance.getDocumentVersions({ documentId });
+        const models = getContentSourceFilteredModelsForUser({
+            user,
+            contentSourceData,
+            configDelegate: createConfigDelegate({
+                contentSourceDataById: this.contentSourceDataById,
+                logger: this.userLogger
+            }),
+            filterModel: this.stackbitConfig?.filterModel
+        });
         const apiVersions = mapDocumentVersionsToApiDocumentVersions({
             assetSources: this.stackbitConfig?.assetSources ?? [],
             customActionRunStateMap: this.customActionRunStateMap,
@@ -2797,7 +3023,8 @@ export class ContentStore {
             versions,
             contentSourceData,
             contentSourceDataById: this.contentSourceDataById,
-            locale
+            locale,
+            modelMap: getModelMap({ models })
         });
 
         return { versions: apiVersions };
@@ -2808,13 +3035,15 @@ export class ContentStore {
         srcProjectId,
         documentId,
         versionId,
-        locale
+        locale,
+        user
     }: {
         srcType: string;
         srcProjectId: string;
         documentId: string;
         versionId: string;
         locale?: string;
+        user?: ContentStoreTypes.User;
     }): Promise<{ version: ContentStoreTypes.APIDocumentVersionWithDocument }> {
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
@@ -2832,6 +3061,15 @@ export class ContentStore {
         }
 
         const { version } = await contentSourceData.instance.getDocumentForVersion({ documentId, versionId });
+        const models = getContentSourceFilteredModelsForUser({
+            user,
+            contentSourceData,
+            configDelegate: createConfigDelegate({
+                contentSourceDataById: this.contentSourceDataById,
+                logger: this.userLogger
+            }),
+            filterModel: this.stackbitConfig?.filterModel
+        });
         const [apiVersion] = mapDocumentVersionsToApiDocumentVersions({
             versions: [version],
             assetSources: this.stackbitConfig?.assetSources ?? [],
@@ -2842,7 +3080,8 @@ export class ContentStore {
             }),
             contentSourceData,
             locale,
-            contentSourceDataById: this.contentSourceDataById
+            contentSourceDataById: this.contentSourceDataById,
+            modelMap: getModelMap({ models })
         });
 
         if (!apiVersion || !apiVersion.object || !apiVersion.document || !apiVersion.apiDocument) {

package/src/types/content-store-documents.ts

@@ -17,6 +17,7 @@ export interface Document {
     srcModelName: string;
     srcModelLabel: string;
     isChanged: boolean;
+    hidden?: boolean;
     status: DocumentStatus;
     createdAt: string;
     createdBy?: string;
@@ -44,6 +45,7 @@ export interface Asset {
     srcModelName: string;
     srcModelLabel: string;
     isChanged: boolean;
+    hidden?: boolean;
     status: DocumentStatus;
     createdAt: string;
     createdBy?: string;

package/src/types/content-store-types.ts

@@ -1,5 +1,5 @@
 import * as StackbitTypes from '@stackbit/types';
-import { Model } from '@stackbit/sdk';
+import { ImageModel, Model } from '@stackbit/sdk';
 import { Asset, Document } from './content-store-documents';
 import { BackCompatContentSourceInterface } from '../utils/backward-compatibility';
 
@@ -121,3 +121,5 @@ export interface ContentStoreLocale {
     locales: string[];
     defaultLocale: string | undefined;
 }
+
+export type RecordSchema = Record<string, Record<string, Record<string, Model | ImageModel>>>;

package/src/types/search-filter.ts

@@ -62,10 +62,14 @@ export type SearchFilterItem =
     | BetweenFilterItem
     | EmptyFilterItem;
 
-export type SearchFilter = LogicalOperator;
+export type SearchFilterItemGrouped = SearchFilterItem | (LogicalAndOperator | LogicalOrOperator);
 
-type LogicalOperator = LogicalAndOperator;
+export type SearchFilter = LogicalAndOperator | LogicalOrOperator;
 
 type LogicalAndOperator = {
-    and: SearchFilterItem[];
+    and: SearchFilterItemGrouped[];
+};
+
+type LogicalOrOperator = {
+    or: SearchFilterItemGrouped[];
 };

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

@@ -12,6 +12,7 @@ type MapDocumentToApiProps = {
     customActionRunStateMap: ContentStoreTypes.CustomActionRunStateMap;
     createConfigDelegate: () => StackbitTypes.ConfigDelegate;
     contentSourceDataById: Record<string, ContentSourceData>;
+    modelMap: Record<string, StackbitTypes.Model>;
 };
 
 export function mapDocumentVersionsToApiDocumentVersions({
@@ -21,7 +22,8 @@ export function mapDocumentVersionsToApiDocumentVersions({
     assetSources,
     customActionRunStateMap,
     createConfigDelegate,
-    contentSourceDataById
+    contentSourceDataById,
+    modelMap
 }: MapDocumentToApiProps & { versions: StackbitTypes.DocumentVersion[] }): ContentStoreTypes.APIDocumentVersion[] {
     return versions.map((version) => {
         if (!version.document) {
@@ -32,8 +34,8 @@ export function mapDocumentVersionsToApiDocumentVersions({
         const contentStoreDocuments = mapCSIDocumentsToStoreDocuments({
             csiDocuments: [version.document],
             contentSourceInstance: contentSourceData.instance,
-            modelMap: contentSourceData.modelMap,
             defaultLocaleCode: contentSourceData.defaultLocaleCode,
+            modelMap,
             createConfigDelegate,
             customActionRunStateMap,
             assetSources,