@stackbit/cms-core 0.0.18-alpha.0 → 0.0.19-alpha.0

package/src/content-store.ts

@@ -16,8 +16,11 @@ import {
     Model
 } from '@stackbit/sdk';
 import { mapPromise, omitByNil } from '@stackbit/utils';
-import * as ContentSourceTypes from './content-source-interface';
-import { isLocalizedField } from './content-source-interface';
+import * as CSITypes from './content-source-interface';
+import {
+    DocumentObjectField,
+    isLocalizedField
+} from './content-source-interface';
 import * as ContentStoreTypes from './content-store-types';
 import { IMAGE_MODEL } from './common/common-schema';
 import { Timer } from './utils/timer';
@@ -27,7 +30,7 @@ export interface ContentSourceOptions {
     userLogger: ContentStoreTypes.Logger;
     localDev: boolean;
     stackbitYamlDir: string;
-    contentSources: ContentSourceTypes.ContentSourceInterface[];
+    contentSources: CSITypes.ContentSourceInterface[];
     onSchemaChangeCallback: () => void;
     onContentChangeCallback: (contentChanges: ContentStoreTypes.ContentChangeResult) => void;
     handleConfigAssets: (config: Config) => Promise<Config>;
@@ -35,21 +38,25 @@ export interface ContentSourceOptions {
 
 interface ContentSourceData {
     id: string;
-    instance: ContentSourceTypes.ContentSourceInterface;
+    instance: CSITypes.ContentSourceInterface;
     type: string;
     projectId: string;
     models: Model[];
     modelMap: Record<string, Model>;
-    locales?: ContentSourceTypes.Locale[];
+    locales?: CSITypes.Locale[];
     defaultLocaleCode?: string;
+    csiDocuments: CSITypes.Document[];
+    csiDocumentMap: Record<string, CSITypes.Document>;
     documents: ContentStoreTypes.Document[];
     documentMap: Record<string, ContentStoreTypes.Document>;
+    csiAssets: CSITypes.Asset[];
+    csiAssetMap: Record<string, CSITypes.Asset>;
     assets: ContentStoreTypes.Asset[];
     assetMap: Record<string, ContentStoreTypes.Asset>;
 }
 
 export class ContentStore {
-    private readonly contentSources: ContentSourceTypes.ContentSourceInterface[];
+    private readonly contentSources: CSITypes.ContentSourceInterface[];
     private readonly logger: ContentStoreTypes.Logger;
     private readonly userLogger: ContentStoreTypes.Logger;
     private readonly localDev: boolean;
@@ -205,7 +212,7 @@ export class ContentStore {
         return config;
     }
 
-    async loadContentSourceData({ contentSourceInstance, init }: { contentSourceInstance: ContentSourceTypes.ContentSourceInterface; init: boolean }) {
+    async loadContentSourceData({ contentSourceInstance, init }: { contentSourceInstance: CSITypes.ContentSourceInterface; init: boolean }) {
         // TODO: defer loading content if content is already loading for a specific content source
 
         // TODO: optimize: cache raw responses from contentSource
@@ -242,19 +249,24 @@ export class ContentStore {
         //  that maps presetIds by model name instead of storing that map inside every model
         this.presets = config.presets;
 
-        const documents = await contentSourceInstance.getDocuments({ modelMap });
-        const assets = await contentSourceInstance.getAssets();
-        const contentStoreDocuments = mapSourceDocumentsToStoreDocuments({
-            documents,
+        const csiDocuments = await contentSourceInstance.getDocuments({ modelMap });
+        const csiAssets = await contentSourceInstance.getAssets();
+        const csiDocumentMap = _.keyBy(csiDocuments, 'id');
+        const csiAssetMap = _.keyBy(csiAssets, 'id');
+
+        const contentStoreDocuments = mapCSIDocumentsToStoreDocuments({
+            csiDocuments,
             contentSourceInstance,
             modelMap,
             defaultLocaleCode
         });
-        const contentStoreAssets = mapSourceAssetsToStoreAssets({
-            assets,
+        const contentStoreAssets = mapCSIAssetsToStoreAssets({
+            csiAssets,
             contentSourceInstance,
             defaultLocaleCode
         });
+        const documentMap = _.keyBy(contentStoreDocuments, 'srcObjectId');
+        const assetMap = _.keyBy(contentStoreAssets, 'srcObjectId');
 
         this.logger.debug('loaded content source data', {
             contentSourceId,
@@ -274,10 +286,14 @@ export class ContentStore {
             defaultLocaleCode: defaultLocaleCode,
             models: models,
             modelMap: modelMap,
+            csiDocuments: csiDocuments,
+            csiDocumentMap: csiDocumentMap,
             documents: contentStoreDocuments,
-            documentMap: _.keyBy(contentStoreDocuments, 'srcObjectId'),
+            documentMap: documentMap,
+            csiAssets: csiAssets,
+            csiAssetMap: csiAssetMap,
             assets: contentStoreAssets,
-            assetMap: _.keyBy(contentStoreAssets, 'srcObjectId')
+            assetMap: assetMap
         };
 
         contentSourceInstance.startWatchingContentUpdates({
@@ -285,7 +301,13 @@ export class ContentStore {
                 const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
                 return contentSourceData.modelMap;
             },
-            onContentChange: (contentChangeEvent: ContentSourceTypes.ContentChangeEvent) => {
+            getDocument({ documentId }: { documentId: string }) {
+                return csiDocumentMap[documentId];
+            },
+            getAsset({ assetId }: { assetId: string }) {
+                return csiAssetMap[assetId];
+            },
+            onContentChange: (contentChangeEvent: CSITypes.ContentChangeEvent) => {
                 this.logger.debug('content source called onContentChange', { contentSourceId });
                 const result = this.onContentChange(contentSourceId, contentChangeEvent);
                 this.onContentChangeCallback(result);
@@ -301,7 +323,7 @@ export class ContentStore {
         });
     }
 
-    onContentChange(contentSourceId: string, contentChangeEvent: ContentSourceTypes.ContentChangeEvent): ContentStoreTypes.ContentChangeResult {
+    onContentChange(contentSourceId: string, contentChangeEvent: CSITypes.ContentChangeEvent): ContentStoreTypes.ContentChangeResult {
         // TODO: prevent content change process for contentSourceId if loading content is in progress
 
         this.logger.debug('onContentChange', {
@@ -320,50 +342,80 @@ export class ContentStore {
         };
 
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
+
+        // update contentSourceData with deleted documents
         contentChangeEvent.deletedDocumentIds.forEach((docId) => {
+            // delete document from documents map
             delete contentSourceData.documentMap[docId];
+            delete contentSourceData.csiDocumentMap[docId];
+
+            // delete document from document array
             const index = contentSourceData.documents.findIndex((document) => document.srcObjectId === docId);
             if (index !== -1) {
+                // the indexes of documents and csiDocuments are always the same as they are always updated at the same time
                 contentSourceData.documents.splice(index, 1);
+                contentSourceData.csiDocuments.splice(index, 1);
             }
+
             result.deletedDocuments.push({
                 srcType: contentSourceData.type,
                 srcProjectId: contentSourceData.projectId,
                 srcObjectId: docId
             });
         });
+
+        // update contentSourceData with deleted assets
         contentChangeEvent.deletedAssetIds.forEach((assetId) => {
+            // delete document from asset map
             delete contentSourceData.assetMap[assetId];
+            delete contentSourceData.csiAssetMap[assetId];
+
+            // delete document from asset array
             const index = contentSourceData.assets.findIndex((asset) => asset.srcObjectId === assetId);
             if (index !== -1) {
+                // the indexes of assets and csiAssets are always the same as they are always updated at the same time
                 contentSourceData.assets.splice(index, 1);
+                contentSourceData.csiAssets.splice(index, 1);
             }
+
             result.deletedAssets.push({
                 srcType: contentSourceData.type,
                 srcProjectId: contentSourceData.projectId,
                 srcObjectId: assetId
             });
         });
-        const documents = mapSourceDocumentsToStoreDocuments({
-            documents: contentChangeEvent.documents,
+
+        // map csi documents and assets to content store documents and assets
+        const documents = mapCSIDocumentsToStoreDocuments({
+            csiDocuments: contentChangeEvent.documents,
             contentSourceInstance: contentSourceData.instance,
             modelMap: contentSourceData.modelMap,
             defaultLocaleCode: contentSourceData.defaultLocaleCode
         });
-        const assets = mapSourceAssetsToStoreAssets({
-            assets: contentChangeEvent.assets,
+        const assets = mapCSIAssetsToStoreAssets({
+            csiAssets: contentChangeEvent.assets,
             contentSourceInstance: contentSourceData.instance,
             defaultLocaleCode: contentSourceData.defaultLocaleCode
         });
 
+        // update contentSourceData with new or updated documents and assets
+        Object.assign(contentSourceData.csiDocumentMap, _.keyBy(contentChangeEvent.documents, 'id'));
+        Object.assign(contentSourceData.csiAssets, _.keyBy(contentChangeEvent.assets, 'id'));
         Object.assign(contentSourceData.documentMap, _.keyBy(documents, 'srcObjectId'));
         Object.assign(contentSourceData.assetMap, _.keyBy(assets, 'srcObjectId'));
-        for (const document of documents) {
-            const index = contentSourceData.documents.findIndex((existingDoc) => existingDoc.srcObjectId === document.srcObjectId);
-            if (index === -1) {
+
+        for (let idx = 0; idx < documents.length; idx++) {
+            // the indexes of mapped documents and documents from changeEvent are the same
+            const document = documents[idx]!;
+            const csiDocument = contentChangeEvent.documents[idx]!;
+            const dataIndex = contentSourceData.documents.findIndex((existingDoc) => existingDoc.srcObjectId === document.srcObjectId);
+            if (dataIndex === -1) {
                 contentSourceData.documents.push(document);
+                contentSourceData.csiDocuments.push(csiDocument)
             } else {
-                contentSourceData.documents.splice(index, 1, document);
+                // the indexes of documents and csiDocuments are always the same as they are always updated at the same time
+                contentSourceData.documents.splice(dataIndex, 1, document);
+                contentSourceData.csiDocuments.splice(dataIndex, 1, csiDocument);
             }
             result.updatedDocuments.push({
                 srcType: contentSourceData.type,
@@ -371,12 +423,19 @@ export class ContentStore {
                 srcObjectId: document.srcObjectId
             });
         }
-        for (const asset of assets) {
+
+        for (let idx = 0; idx < assets.length; idx++) {
+            // the indexes of mapped assets and assets from changeEvent are the same
+            const asset = assets[idx]!;
+            const csiAsset = contentChangeEvent.assets[idx]!;
             const index = contentSourceData.assets.findIndex((existingAsset) => existingAsset.srcObjectId === asset.srcObjectId);
             if (index === -1) {
                 contentSourceData.assets.push(asset);
+                contentSourceData.csiAssets.push(csiAsset);
             } else {
+                // the indexes of assets and csiAssets are always the same as they are always updated at the same time
                 contentSourceData.assets.splice(index, 1, asset);
+                contentSourceData.csiAssets.splice(index, 1, csiAsset);
             }
             result.updatedAssets.push({
                 srcType: contentSourceData.type,
@@ -614,7 +673,8 @@ export class ContentStore {
 
         // get the document that is being updated
         const document = contentSourceData.documentMap[srcDocumentId];
-        if (!document) {
+        const csiDocument = contentSourceData.csiDocumentMap[srcDocumentId];
+        if (!document || !csiDocument) {
             throw new Error(`no document with id '${srcDocumentId}' was found in ${contentSourceData.id}`);
         }
 
@@ -663,7 +723,7 @@ export class ContentStore {
             refId: result.srcDocumentId
         } as const;
         const updatedDocument = await contentSourceData.instance.updateDocument({
-            documentId: srcDocumentId,
+            document: csiDocument,
             modelMap: modelMap,
             userContext: userContext,
             operations: [
@@ -713,7 +773,8 @@ export class ContentStore {
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         const document = contentSourceData.documentMap[srcDocumentId];
-        if (!document) {
+        const csiDocument = contentSourceData.csiDocumentMap[srcDocumentId];
+        if (!document || !csiDocument) {
             throw new Error(`no document with id '${srcDocumentId}' was found in ${contentSourceData.id}`);
         }
 
@@ -753,7 +814,7 @@ export class ContentStore {
             refId: result.id
         } as const;
         const updatedDocument = await contentSourceData.instance.updateDocument({
-            documentId: srcDocumentId,
+            document: csiDocument,
             modelMap: modelMap,
             userContext: userContext,
             operations: [
@@ -841,21 +902,23 @@ export class ContentStore {
 
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-        const modelMap = contentSourceData.modelMap;
         const userContext = getUserContextForSrcType(srcType, user);
+        const document = contentSourceData.documentMap[srcDocumentId];
+        const csiDocument = contentSourceData.csiDocumentMap[srcDocumentId];
+        if (!document || !csiDocument) {
+            throw new Error(`no document with id '${srcDocumentId}' was found in ${contentSourceData.id}`);
+        }
+
+        const modelMap = contentSourceData.modelMap;
+        const documentModelName = document.srcModelName;
+        const model = modelMap[documentModelName];
+        if (!model) {
+            throw new Error(`error updating document, could not find document model: '${documentModelName}'`);
+        }
 
         const operations = await mapPromise(
             updateOperations,
-            async (updateOperation): Promise<ContentSourceTypes.UpdateOperation> => {
-                const document = contentSourceData.documentMap[srcDocumentId];
-                if (!document) {
-                    throw new Error(`no document with id '${srcDocumentId}' was found in ${contentSourceData.id}`);
-                }
-                const documentModelName = document.srcModelName;
-                const model = modelMap[documentModelName];
-                if (!model) {
-                    throw new Error(`error updating document, could not find document model: '${documentModelName}'`);
-                }
+            async (updateOperation): Promise<CSITypes.UpdateOperation> => {
                 const locale = updateOperation.locale ?? contentSourceData.defaultLocaleCode;
                 const modelField = getModelFieldForFieldAtPath(document, model, updateOperation.fieldPath, modelMap, locale);
                 switch (updateOperation.opType) {
@@ -899,8 +962,8 @@ export class ContentStore {
             }
         );
 
-        const document = await contentSourceData.instance.updateDocument({
-            documentId: srcDocumentId,
+        const updatedDocumentResult = await contentSourceData.instance.updateDocument({
+            document: csiDocument,
             modelMap,
             userContext,
             operations
@@ -911,7 +974,7 @@ export class ContentStore {
         // and use data from contentChangeEvent to update the cache
         // contentSourceData.documentMap = Object.assign(contentSourceData.documentMap, { [document.srcObjectId]: document });
 
-        return { srcDocumentId: document.id };
+        return { srcDocumentId: updatedDocumentResult.id };
     }
 
     async duplicateDocument({
@@ -976,7 +1039,7 @@ export class ContentStore {
 
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-        const sourceAssets: ContentSourceTypes.Asset[] = [];
+        const sourceAssets: CSITypes.Asset[] = [];
         const userContext = getUserContextForSrcType(srcType, user);
 
         locale = locale ?? contentSourceData.defaultLocaleCode;
@@ -999,8 +1062,8 @@ export class ContentStore {
             });
             sourceAssets.push(sourceAsset);
         }
-        const storeAssets = mapSourceAssetsToStoreAssets({
-            assets: sourceAssets,
+        const storeAssets = mapCSIAssetsToStoreAssets({
+            csiAssets: sourceAssets,
             contentSourceInstance: contentSourceData.instance,
             defaultLocaleCode: contentSourceData.defaultLocaleCode
         });
@@ -1023,7 +1086,11 @@ export class ContentStore {
         const userContext = getUserContextForSrcType(srcType, user);
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-        await contentSourceData.instance.deleteDocument({ documentId: srcDocumentId, userContext });
+        const csiDocument = contentSourceData.csiDocumentMap[srcDocumentId];
+        if (!csiDocument) {
+            throw new Error(`no document with id '${srcDocumentId}' was found in ${contentSourceData.id}`);
+        }
+        await contentSourceData.instance.deleteDocument({ document: csiDocument, userContext });
 
         // do not update cache in contentSourceData.documents and documentMap,
         // instead wait for contentSource to call onContentChange(contentChangeEvent)
@@ -1044,20 +1111,12 @@ export class ContentStore {
 
         const objectsBySourceId = _.groupBy(objects, (object) => getContentSourceId(object.srcType, object.srcProjectId));
         let errors: ContentStoreTypes.ValidationError[] = [];
-        for (const [contentSourceId, objects] of Object.entries(objectsBySourceId)) {
+        for (const [contentSourceId, contentSourceObjects] of Object.entries(objectsBySourceId)) {
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
             locale = locale ?? contentSourceData.defaultLocaleCode;
-            const documentIds = [];
-            const assetIds = [];
-            for (const object of objects) {
-                if (object.srcObjectId in contentSourceData.documentMap) {
-                    documentIds.push(object.srcObjectId);
-                } else if (object.srcObjectId in contentSourceData.assetMap) {
-                    assetIds.push(object.srcObjectId);
-                }
-            }
+            const { documents, assets } = getCSIDocumentsAndAssetsFromContentSourceDataByIds(contentSourceData, contentSourceObjects);
             const userContext = getUserContextForSrcType(contentSourceData.type, user);
-            const validationResult = await contentSourceData.instance.validateDocuments({ documentIds, assetIds, locale, userContext });
+            const validationResult = await contentSourceData.instance.validateDocuments({ documents, assets, locale, userContext });
             errors = errors.concat(
                 validationResult.errors.map((validationError) => ({
                     message: validationError.message,
@@ -1093,19 +1152,11 @@ export class ContentStore {
         this.logger.debug('publishDocuments');
 
         const objectsBySourceId = _.groupBy(objects, (object) => getContentSourceId(object.srcType, object.srcProjectId));
-        for (const [contentSourceId, objects] of Object.entries(objectsBySourceId)) {
+        for (const [contentSourceId, contentSourceObjects] of Object.entries(objectsBySourceId)) {
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
             const userContext = getUserContextForSrcType(contentSourceData.type, user);
-            const documentIds = [];
-            const assetIds = [];
-            for (const object of objects) {
-                if (object.srcObjectId in contentSourceData.documentMap) {
-                    documentIds.push(object.srcObjectId);
-                } else if (object.srcObjectId in contentSourceData.assetMap) {
-                    assetIds.push(object.srcObjectId);
-                }
-            }
-            await contentSourceData.instance.publishDocuments({ documentIds, assetIds, userContext });
+            const { documents, assets } = getCSIDocumentsAndAssetsFromContentSourceDataByIds(contentSourceData, contentSourceObjects);
+            await contentSourceData.instance.publishDocuments({ documents, assets, userContext });
         }
     }
 
@@ -1126,13 +1177,13 @@ function getUserContextForSrcType(srcType: string, user?: ContentStoreTypes.User
     return user?.connections?.find((connection) => connection.type === srcType);
 }
 
-function mapSourceAssetsToStoreAssets({
-    assets,
+function mapCSIAssetsToStoreAssets({
+    csiAssets,
     contentSourceInstance,
     defaultLocaleCode
 }: {
-    assets: ContentSourceTypes.Asset[];
-    contentSourceInstance: ContentSourceTypes.ContentSourceInterface;
+    csiAssets: CSITypes.Asset[];
+    contentSourceInstance: CSITypes.ContentSourceInterface;
     defaultLocaleCode?: string;
 }): ContentStoreTypes.Asset[] {
     const extra = {
@@ -1141,53 +1192,53 @@ function mapSourceAssetsToStoreAssets({
         srcProjectUrl: contentSourceInstance.getProjectManageUrl(),
         srcEnvironment: contentSourceInstance.getProjectEnvironment()
     };
-    return assets.map((asset) => sourceAssetToStoreAsset({ asset, defaultLocaleCode, extra }));
+    return csiAssets.map((csiAsset) => sourceAssetToStoreAsset({ csiAsset, defaultLocaleCode, extra }));
 }
 
 function sourceAssetToStoreAsset({
-    asset,
+    csiAsset,
     defaultLocaleCode,
     extra
 }: {
-    asset: ContentSourceTypes.Asset;
+    csiAsset: CSITypes.Asset;
     defaultLocaleCode?: string;
     extra: { srcType: string; srcProjectId: string; srcProjectUrl: string; srcEnvironment: string };
 }): ContentStoreTypes.Asset {
     return {
         type: 'asset',
         ...extra,
-        srcObjectId: asset.id,
-        srcObjectUrl: asset.manageUrl,
-        srcObjectLabel: getObjectLabel(asset.fields, IMAGE_MODEL, defaultLocaleCode),
+        srcObjectId: csiAsset.id,
+        srcObjectUrl: csiAsset.manageUrl,
+        srcObjectLabel: getObjectLabel(csiAsset.fields, IMAGE_MODEL, defaultLocaleCode),
         srcModelName: IMAGE_MODEL.name,
         srcModelLabel: IMAGE_MODEL.label!,
-        isChanged: asset.status === 'added' || asset.status === 'modified',
-        status: asset.status,
-        createdAt: asset.createdAt,
-        createdBy: asset.createdBy,
-        updatedAt: asset.updatedAt,
-        updatedBy: asset.updatedBy,
+        isChanged: csiAsset.status === 'added' || csiAsset.status === 'modified',
+        status: csiAsset.status,
+        createdAt: csiAsset.createdAt,
+        createdBy: csiAsset.createdBy,
+        updatedAt: csiAsset.updatedAt,
+        updatedBy: csiAsset.updatedBy,
         fields: {
             title: {
                 label: 'Title',
-                ...asset.fields.title
+                ...csiAsset.fields.title
             },
             file: {
                 label: 'File',
-                ...asset.fields.file
+                ...csiAsset.fields.file
             }
         }
     };
 }
 
-function mapSourceDocumentsToStoreDocuments({
-    documents,
+function mapCSIDocumentsToStoreDocuments({
+    csiDocuments,
     contentSourceInstance,
     modelMap,
     defaultLocaleCode
 }: {
-    documents: ContentSourceTypes.Document[];
-    contentSourceInstance: ContentSourceTypes.ContentSourceInterface;
+    csiDocuments: CSITypes.Document[];
+    contentSourceInstance: CSITypes.ContentSourceInterface;
     modelMap: Record<string, Model>;
     defaultLocaleCode?: string;
 }): ContentStoreTypes.Document[] {
@@ -1197,19 +1248,19 @@ function mapSourceDocumentsToStoreDocuments({
         srcProjectUrl: contentSourceInstance.getProjectManageUrl(),
         srcEnvironment: contentSourceInstance.getProjectEnvironment()
     };
-    return documents.map((document) =>
-        mapSourceDocumentToStoreDocument({ document, model: modelMap[document.modelName]!, modelMap, defaultLocaleCode, extra })
+    return csiDocuments.map((csiDocument) =>
+        mapCSIDocumentToStoreDocument({ csiDocument, model: modelMap[csiDocument.modelName]!, modelMap, defaultLocaleCode, extra })
     );
 }
 
-function mapSourceDocumentToStoreDocument({
-    document,
+function mapCSIDocumentToStoreDocument({
+    csiDocument,
     model,
     modelMap,
     defaultLocaleCode,
     extra
 }: {
-    document: ContentSourceTypes.Document;
+    csiDocument: CSITypes.Document;
     model: Model;
     modelMap: Record<string, Model>;
     defaultLocaleCode?: string;
@@ -1218,19 +1269,19 @@ function mapSourceDocumentToStoreDocument({
     return {
         type: 'document',
         ...extra,
-        srcObjectId: document.id,
-        srcObjectUrl: document.manageUrl,
-        srcObjectLabel: getObjectLabel(document.fields, model, defaultLocaleCode),
-        srcModelLabel: model.label ?? _.startCase(document.modelName),
-        srcModelName: document.modelName,
-        isChanged: document.status === 'added' || document.status === 'modified',
-        status: document.status,
-        createdAt: document.createdAt,
-        createdBy: document.createdBy,
-        updatedAt: document.updatedAt,
-        updatedBy: document.updatedBy,
-        fields: mapSourceFieldsToStoreFields({
-            documentFields: document.fields,
+        srcObjectId: csiDocument.id,
+        srcObjectUrl: csiDocument.manageUrl,
+        srcObjectLabel: getObjectLabel(csiDocument.fields, model, defaultLocaleCode),
+        srcModelLabel: model.label ?? _.startCase(csiDocument.modelName),
+        srcModelName: csiDocument.modelName,
+        isChanged: csiDocument.status === 'added' || csiDocument.status === 'modified',
+        status: csiDocument.status,
+        createdAt: csiDocument.createdAt,
+        createdBy: csiDocument.createdBy,
+        updatedAt: csiDocument.updatedAt,
+        updatedBy: csiDocument.updatedBy,
+        fields: mapCSIFieldsToStoreFields({
+            csiDocumentFields: csiDocument.fields,
             modelFields: model.fields ?? [],
             modelMap,
             defaultLocaleCode
@@ -1238,21 +1289,21 @@ function mapSourceDocumentToStoreDocument({
     };
 }
 
-function mapSourceFieldsToStoreFields({
-    documentFields,
+function mapCSIFieldsToStoreFields({
+    csiDocumentFields,
     modelFields,
     modelMap,
     defaultLocaleCode
 }: {
-    documentFields: Record<string, ContentSourceTypes.DocumentField>;
+    csiDocumentFields: Record<string, CSITypes.DocumentField>;
     modelFields: Field[];
     modelMap: Record<string, Model>;
     defaultLocaleCode?: string;
 }): Record<string, ContentStoreTypes.DocumentField> {
     return modelFields.reduce((result: Record<string, ContentStoreTypes.DocumentField>, modelField) => {
-        const documentField = documentFields[modelField.name];
+        const csiDocumentField = csiDocumentFields[modelField.name];
         const docField = mapSourceFieldToStoreField({
-            documentField,
+            csiDocumentField,
             modelField,
             modelMap,
             defaultLocaleCode
@@ -1264,17 +1315,17 @@ function mapSourceFieldsToStoreFields({
 }
 
 function mapSourceFieldToStoreField({
-    documentField,
+    csiDocumentField,
     modelField,
     modelMap,
     defaultLocaleCode
 }: {
-    documentField: ContentSourceTypes.DocumentField | undefined;
+    csiDocumentField: CSITypes.DocumentField | undefined;
     modelField: FieldSpecificProps;
     modelMap: Record<string, Model>;
     defaultLocaleCode?: string;
 }): ContentStoreTypes.DocumentField {
-    if (!documentField) {
+    if (!csiDocumentField) {
         const isUnset = ['object', 'model', 'reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(modelField.type);
         return {
             type: modelField.type,
@@ -1285,32 +1336,32 @@ function mapSourceFieldToStoreField({
     // TODO: check if need to add "options" to "enum" and subtype/min/max to "number"
     switch (modelField.type) {
         case 'object':
-            return mapObjectField(documentField as ContentSourceTypes.DocumentFieldForType<typeof modelField.type>, modelField, modelMap, defaultLocaleCode);
+            return mapObjectField(csiDocumentField as CSITypes.DocumentObjectField, modelField, modelMap, defaultLocaleCode);
         case 'model':
-            return mapModelField(documentField as ContentSourceTypes.DocumentModelField, modelField, modelMap, defaultLocaleCode);
+            return mapModelField(csiDocumentField as CSITypes.DocumentModelField, modelField, modelMap, defaultLocaleCode);
         case 'list':
-            return mapListField(documentField as ContentSourceTypes.DocumentListField, modelField, modelMap, defaultLocaleCode);
+            return mapListField(csiDocumentField as CSITypes.DocumentListField, modelField, modelMap, defaultLocaleCode);
         case 'richText':
-            return mapRichTextField(documentField as ContentSourceTypes.DocumentRichTextField);
+            return mapRichTextField(csiDocumentField as CSITypes.DocumentRichTextField);
         case 'markdown':
-            return mapMarkdownField(documentField as ContentSourceTypes.DocumentValueField);
+            return mapMarkdownField(csiDocumentField as CSITypes.DocumentValueField);
         default:
-            return documentField as ContentStoreTypes.DocumentField;
+            return csiDocumentField as ContentStoreTypes.DocumentField;
     }
 }
 
 function mapObjectField(
-    documentField: ContentSourceTypes.DocumentObjectField,
+    csiDocumentField: CSITypes.DocumentObjectField,
     modelField: FieldObjectProps,
     modelMap: Record<string, Model>,
     defaultLocaleCode?: string
 ): ContentStoreTypes.DocumentObjectField {
-    if (!isLocalizedField(documentField)) {
+    if (!isLocalizedField(csiDocumentField)) {
         return {
-            type: documentField.type,
-            srcObjectLabel: getObjectLabel(documentField.fields ?? {}, modelField ?? [], defaultLocaleCode),
-            fields: mapSourceFieldsToStoreFields({
-                documentFields: documentField.fields ?? {},
+            type: csiDocumentField.type,
+            srcObjectLabel: getObjectLabel(csiDocumentField.fields ?? {}, modelField ?? [], defaultLocaleCode),
+            fields: mapCSIFieldsToStoreFields({
+                csiDocumentFields: csiDocumentField.fields ?? {},
                 modelFields: modelField.fields ?? [],
                 modelMap,
                 defaultLocaleCode
@@ -1318,14 +1369,14 @@ function mapObjectField(
         };
     }
     return {
-        type: documentField.type,
+        type: csiDocumentField.type,
         localized: true,
-        locales: _.mapValues(documentField.locales, (locale) => {
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
             return {
                 locale: locale.locale,
                 srcObjectLabel: getObjectLabel(locale.fields ?? {}, modelField, locale.locale),
-                fields: mapSourceFieldsToStoreFields({
-                    documentFields: locale.fields ?? {},
+                fields: mapCSIFieldsToStoreFields({
+                    csiDocumentFields: locale.fields ?? {},
                     modelFields: modelField.fields ?? [],
                     modelMap,
                     defaultLocaleCode
@@ -1336,20 +1387,20 @@ function mapObjectField(
 }
 
 function mapModelField(
-    documentField: ContentSourceTypes.DocumentModelField,
+    csiDocumentField: CSITypes.DocumentModelField,
     modelField: FieldModelProps,
     modelMap: Record<string, Model>,
     defaultLocaleCode?: string
 ): ContentStoreTypes.DocumentModelField {
-    if (!isLocalizedField(documentField)) {
-        const model = modelMap[documentField.modelName]!;
+    if (!isLocalizedField(csiDocumentField)) {
+        const model = modelMap[csiDocumentField.modelName]!;
         return {
-            type: documentField.type,
-            srcObjectLabel: getObjectLabel(documentField.fields ?? {}, model, defaultLocaleCode),
-            srcModelName: documentField.modelName,
+            type: csiDocumentField.type,
+            srcObjectLabel: getObjectLabel(csiDocumentField.fields ?? {}, model, defaultLocaleCode),
+            srcModelName: csiDocumentField.modelName,
             srcModelLabel: model.label ?? _.startCase(model.name),
-            fields: mapSourceFieldsToStoreFields({
-                documentFields: documentField.fields ?? {},
+            fields: mapCSIFieldsToStoreFields({
+                csiDocumentFields: csiDocumentField.fields ?? {},
                 modelFields: model.fields ?? [],
                 modelMap,
                 defaultLocaleCode
@@ -1357,17 +1408,17 @@ function mapModelField(
         };
     }
     return {
-        type: documentField.type,
+        type: csiDocumentField.type,
         localized: true,
-        locales: _.mapValues(documentField.locales, (locale) => {
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
             const model = modelMap[locale.modelName]!;
             return {
                 locale: locale.locale,
                 srcObjectLabel: getObjectLabel(locale.fields ?? {}, model, locale.locale),
                 srcModelName: locale.modelName,
                 srcModelLabel: model.label ?? _.startCase(model.name),
-                fields: mapSourceFieldsToStoreFields({
-                    documentFields: locale.fields ?? {},
+                fields: mapCSIFieldsToStoreFields({
+                    csiDocumentFields: locale.fields ?? {},
                     modelFields: model.fields ?? [],
                     modelMap,
                     defaultLocaleCode
@@ -1378,17 +1429,17 @@ function mapModelField(
 }
 
 function mapListField(
-    documentField: ContentSourceTypes.DocumentListField,
+    csiDocumentField: CSITypes.DocumentListField,
     modelField: FieldListProps,
     modelMap: Record<string, Model>,
     defaultLocaleCode?: string
 ): ContentStoreTypes.DocumentListField {
-    if (!isLocalizedField(documentField)) {
+    if (!isLocalizedField(csiDocumentField)) {
         return {
-            type: documentField.type,
-            items: documentField.items.map((item) =>
+            type: csiDocumentField.type,
+            items: csiDocumentField.items.map((item) =>
                 mapSourceFieldToStoreField({
-                    documentField: item,
+                    csiDocumentField: item,
                     modelField: modelField.items ?? { type: 'string' },
                     modelMap,
                     defaultLocaleCode
@@ -1397,14 +1448,14 @@ function mapListField(
         };
     }
     return {
-        type: documentField.type,
+        type: csiDocumentField.type,
         localized: true,
-        locales: _.mapValues(documentField.locales, (locale) => {
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
             return {
                 locale: locale.locale,
                 items: (locale.items ?? []).map((item) =>
                     mapSourceFieldToStoreField({
-                        documentField: item,
+                        csiDocumentField: item,
                         modelField: modelField.items ?? { type: 'string' },
                         modelMap,
                         defaultLocaleCode
@@ -1415,17 +1466,17 @@ function mapListField(
     };
 }
 
-function mapRichTextField(documentField: ContentSourceTypes.DocumentRichTextField): ContentStoreTypes.DocumentRichTextField {
-    if (!isLocalizedField(documentField)) {
+function mapRichTextField(csiDocumentField: CSITypes.DocumentRichTextField): ContentStoreTypes.DocumentRichTextField {
+    if (!isLocalizedField(csiDocumentField)) {
         return {
-            ...documentField,
+            ...csiDocumentField,
             multiElement: true
         };
     }
     return {
-        type: documentField.type,
+        type: csiDocumentField.type,
         localized: true,
-        locales: _.mapValues(documentField.locales, (locale) => {
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
             return {
                 ...locale,
                 multiElement: true
@@ -1434,18 +1485,18 @@ function mapRichTextField(documentField: ContentSourceTypes.DocumentRichTextFiel
     };
 }
 
-function mapMarkdownField(documentField: ContentSourceTypes.DocumentValueField): ContentStoreTypes.DocumentMarkdownField {
-    if (!isLocalizedField(documentField)) {
+function mapMarkdownField(csiDocumentField: CSITypes.DocumentValueField): ContentStoreTypes.DocumentMarkdownField {
+    if (!isLocalizedField(csiDocumentField)) {
         return {
             type: 'markdown',
-            value: documentField.value,
+            value: csiDocumentField.value,
             multiElement: true
         };
     }
     return {
         type: 'markdown',
         localized: true,
-        locales: _.mapValues(documentField.locales, (locale) => {
+        locales: _.mapValues(csiDocumentField.locales, (locale) => {
             return {
                 ...locale,
                 multiElement: true
@@ -1462,12 +1513,12 @@ function mapStoreFieldsToSourceFields({
     documentFields: Record<string, ContentStoreTypes.DocumentField>;
     modelFields: Field[];
     modelMap: Record<string, Model>;
-}): Record<string, ContentSourceTypes.DocumentField> {
-    // TODO:
+}): Record<string, CSITypes.DocumentField> {
+    // TODO: implement
     throw new Error(`duplicateDocument not implemented yet`);
 }
 
-function getContentSourceIdForContentSource(contentSource: ContentSourceTypes.ContentSourceInterface): string {
+function getContentSourceIdForContentSource(contentSource: CSITypes.ContentSourceInterface): string {
     return getContentSourceId(contentSource.getContentSourceType(), contentSource.getProjectId());
 }
 
@@ -1483,7 +1534,7 @@ function sanitizeSlug(slug: string) {
 }
 
 function getObjectLabel(
-    documentFields: Record<string, ContentSourceTypes.DocumentField | ContentSourceTypes.AssetFileField>,
+    documentFields: Record<string, CSITypes.DocumentField | CSITypes.AssetFileField>,
     modelOrObjectField: Model | FieldObjectProps,
     locale?: string
 ): string {
@@ -1671,8 +1722,8 @@ async function createDocumentRecursively({
     modelMap: Record<string, Model>;
     locale?: string;
     userContext: unknown;
-    contentSourceInstance: ContentSourceTypes.ContentSourceInterface;
-}): Promise<{ document: ContentSourceTypes.Document; newRefDocuments: ContentSourceTypes.Document[] }> {
+    contentSourceInstance: CSITypes.ContentSourceInterface;
+}): Promise<{ document: CSITypes.Document; newRefDocuments: CSITypes.Document[] }> {
     if (model.type === 'page') {
         const tokens = extractTokensFromString(String(model.urlPath));
         const slugField = _.last(tokens);
@@ -1719,10 +1770,10 @@ async function createNestedObjectRecursively({
     modelMap: Record<string, Model>;
     locale?: string;
     userContext: unknown;
-    contentSourceInstance: ContentSourceTypes.ContentSourceInterface;
+    contentSourceInstance: CSITypes.ContentSourceInterface;
 }): Promise<{
-    fields: Record<string, ContentSourceTypes.DocumentFieldNonLocalized>;
-    newRefDocuments: ContentSourceTypes.Document[];
+    fields: Record<string, CSITypes.DocumentFieldNonLocalized>;
+    newRefDocuments: CSITypes.Document[];
 }> {
     const createNestedField = async ({
         value,
@@ -1732,7 +1783,7 @@ async function createNestedObjectRecursively({
         value: any;
         modelField: FieldSpecificProps;
         fieldPath: (string | number)[];
-    }): Promise<{ field: ContentSourceTypes.DocumentFieldNonLocalized; newRefDocuments: ContentSourceTypes.Document[] }> => {
+    }): Promise<{ field: CSITypes.DocumentFieldNonLocalized; newRefDocuments: CSITypes.Document[] }> => {
         if (modelField.type === 'object') {
             const result = await createNestedObjectRecursively({
                 object: value,
@@ -1866,22 +1917,22 @@ async function createNestedObjectRecursively({
                     type: 'list',
                     items: arrayResult.map((result) => result.field)
                 },
-                newRefDocuments: arrayResult.reduce((result: ContentSourceTypes.Document[], { newRefDocuments }) => result.concat(newRefDocuments), [])
+                newRefDocuments: arrayResult.reduce((result: CSITypes.Document[], { newRefDocuments }) => result.concat(newRefDocuments), [])
             };
         }
         return {
             field: {
                 type: modelField.type,
                 value: value
-            } as ContentSourceTypes.DocumentFieldNonLocalized,
+            } as CSITypes.DocumentFieldNonLocalized,
             newRefDocuments: []
         };
     };
 
     object = object ?? {};
     const result: {
-        fields: Record<string, ContentSourceTypes.DocumentFieldNonLocalized>;
-        newRefDocuments: ContentSourceTypes.Document[];
+        fields: Record<string, CSITypes.DocumentFieldNonLocalized>;
+        newRefDocuments: CSITypes.Document[];
     } = {
         fields: {},
         newRefDocuments: []
@@ -2040,8 +2091,8 @@ async function convertOperationField({
     modelMap: Record<string, Model>;
     locale?: string;
     userContext: unknown;
-    contentSourceInstance: ContentSourceTypes.ContentSourceInterface;
-}): Promise<ContentSourceTypes.UpdateOperationField> {
+    contentSourceInstance: CSITypes.ContentSourceInterface;
+}): Promise<CSITypes.UpdateOperationField> {
     let result;
     switch (operationField.type) {
         case 'object':
@@ -2078,7 +2129,7 @@ async function convertOperationField({
                 fields: result.fields
             };
         default:
-            return operationField as ContentSourceTypes.UpdateOperationField;
+            return operationField as CSITypes.UpdateOperationField;
     }
 }
 
@@ -2110,3 +2161,25 @@ function isStackbitConfigFile(filePath: string) {
     const isMainStackbitConfigFile = pathObject.name === 'stackbit' && ['yaml', 'yml'].includes(pathObject.ext.substring(1));
     return isMainStackbitConfigFile || isInDotStackbitFolder;
 }
+
+function getCSIDocumentsAndAssetsFromContentSourceDataByIds(
+    contentSourceData: ContentSourceData,
+    objects: { srcObjectId: string }[]
+): {
+    documents: CSITypes.Document[];
+    assets: CSITypes.Asset[];
+} {
+    const documents: CSITypes.Document[] = [];
+    const assets: CSITypes.Asset[] = [];
+    for (const object of objects) {
+        if (object.srcObjectId in contentSourceData.csiDocumentMap) {
+            documents.push(contentSourceData.csiDocumentMap[object.srcObjectId]!);
+        } else if (object.srcObjectId in contentSourceData.csiAssetMap) {
+            assets.push(contentSourceData.csiAssetMap[object.srcObjectId]!);
+        }
+    }
+    return {
+        documents,
+        assets
+    };
+}