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

package/dist/content-store.js

@@ -173,19 +173,23 @@ class ContentStore {
         // TODO: load presets externally from config, and create additional map
         //  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 = lodash_1.default.keyBy(csiDocuments, 'id');
+        const csiAssetMap = lodash_1.default.keyBy(csiAssets, 'id');
+        const contentStoreDocuments = mapCSIDocumentsToStoreDocuments({
+            csiDocuments,
             contentSourceInstance,
             modelMap,
             defaultLocaleCode
         });
-        const contentStoreAssets = mapSourceAssetsToStoreAssets({
-            assets,
+        const contentStoreAssets = mapCSIAssetsToStoreAssets({
+            csiAssets,
             contentSourceInstance,
             defaultLocaleCode
         });
+        const documentMap = lodash_1.default.keyBy(contentStoreDocuments, 'srcObjectId');
+        const assetMap = lodash_1.default.keyBy(contentStoreAssets, 'srcObjectId');
         this.logger.debug('loaded content source data', {
             contentSourceId,
             locales,
@@ -203,16 +207,26 @@ class ContentStore {
             defaultLocaleCode: defaultLocaleCode,
             models: models,
             modelMap: modelMap,
+            csiDocuments: csiDocuments,
+            csiDocumentMap: csiDocumentMap,
             documents: contentStoreDocuments,
-            documentMap: lodash_1.default.keyBy(contentStoreDocuments, 'srcObjectId'),
+            documentMap: documentMap,
+            csiAssets: csiAssets,
+            csiAssetMap: csiAssetMap,
             assets: contentStoreAssets,
-            assetMap: lodash_1.default.keyBy(contentStoreAssets, 'srcObjectId')
+            assetMap: assetMap
         };
         contentSourceInstance.startWatchingContentUpdates({
             getModelMap: () => {
                 const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
                 return contentSourceData.modelMap;
             },
+            getDocument({ documentId }) {
+                return csiDocumentMap[documentId];
+            },
+            getAsset({ assetId }) {
+                return csiAssetMap[assetId];
+            },
             onContentChange: (contentChangeEvent) => {
                 this.logger.debug('content source called onContentChange', { contentSourceId });
                 const result = this.onContentChange(contentSourceId, contentChangeEvent);
@@ -244,11 +258,17 @@ class ContentStore {
             deletedAssets: []
         };
         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,
@@ -256,11 +276,17 @@ class ContentStore {
                 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,
@@ -268,26 +294,36 @@ class ContentStore {
                 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, lodash_1.default.keyBy(contentChangeEvent.documents, 'id'));
+        Object.assign(contentSourceData.csiAssets, lodash_1.default.keyBy(contentChangeEvent.assets, 'id'));
         Object.assign(contentSourceData.documentMap, lodash_1.default.keyBy(documents, 'srcObjectId'));
         Object.assign(contentSourceData.assetMap, lodash_1.default.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,
@@ -295,13 +331,19 @@ 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,
@@ -441,7 +483,8 @@ class ContentStore {
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
         // 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}`);
         }
         // get the document model
@@ -485,7 +528,7 @@ class ContentStore {
             refId: result.srcDocumentId
         };
         const updatedDocument = await contentSourceData.instance.updateDocument({
-            documentId: srcDocumentId,
+            document: csiDocument,
             modelMap: modelMap,
             userContext: userContext,
             operations: [
@@ -515,7 +558,8 @@ 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}`);
         }
         // get the document model
@@ -551,7 +595,7 @@ class ContentStore {
             refId: result.id
         };
         const updatedDocument = await contentSourceData.instance.updateDocument({
-            documentId: srcDocumentId,
+            document: csiDocument,
             modelMap: modelMap,
             userContext: userContext,
             operations: [
@@ -606,19 +650,20 @@ class ContentStore {
         this.logger.debug('updateDocument');
         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 (0, utils_1.mapPromise)(updateOperations, async (updateOperation) => {
             var _a;
-            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}'`);
-            }
             const locale = (_a = updateOperation.locale) !== null && _a !== void 0 ? _a : contentSourceData.defaultLocaleCode;
             const modelField = getModelFieldForFieldAtPath(document, model, updateOperation.fieldPath, modelMap, locale);
             switch (updateOperation.opType) {
@@ -660,8 +705,8 @@ class ContentStore {
                     return { ...updateOperation, modelField };
             }
         });
-        const document = await contentSourceData.instance.updateDocument({
-            documentId: srcDocumentId,
+        const updatedDocumentResult = await contentSourceData.instance.updateDocument({
+            document: csiDocument,
             modelMap,
             userContext,
             operations
@@ -670,7 +715,7 @@ class ContentStore {
         // instead wait for contentSource to call onContentChange(contentChangeEvent)
         // 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({ srcType, srcProjectId, srcDocumentId, object, user }) {
         this.logger.debug('duplicateDocument');
@@ -726,8 +771,8 @@ class ContentStore {
             });
             sourceAssets.push(sourceAsset);
         }
-        const storeAssets = mapSourceAssetsToStoreAssets({
-            assets: sourceAssets,
+        const storeAssets = mapCSIAssetsToStoreAssets({
+            csiAssets: sourceAssets,
             contentSourceInstance: contentSourceData.instance,
             defaultLocaleCode: contentSourceData.defaultLocaleCode
         });
@@ -738,7 +783,11 @@ 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)
         // and use data from contentChangeEvent to update the cache
@@ -748,21 +797,12 @@ class ContentStore {
         this.logger.debug('validateDocuments');
         const objectsBySourceId = lodash_1.default.groupBy(objects, (object) => getContentSourceId(object.srcType, object.srcProjectId));
         let errors = [];
-        for (const [contentSourceId, objects] of Object.entries(objectsBySourceId)) {
+        for (const [contentSourceId, contentSourceObjects] of Object.entries(objectsBySourceId)) {
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
             locale = locale !== null && locale !== void 0 ? 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,
                 srcType: contentSourceData.type,
@@ -792,20 +832,11 @@ class ContentStore {
     async publishDocuments({ objects, user }) {
         this.logger.debug('publishDocuments');
         const objectsBySourceId = lodash_1.default.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 });
         }
     }
     getContentSourceDataByIdOrThrow(contentSourceId) {
@@ -825,80 +856,80 @@ function getUserContextForSrcType(srcType, user) {
     var _a;
     return (_a = user === null || user === void 0 ? void 0 : user.connections) === null || _a === void 0 ? void 0 : _a.find((connection) => connection.type === srcType);
 }
-function mapSourceAssetsToStoreAssets({ assets, contentSourceInstance, defaultLocaleCode }) {
+function mapCSIAssetsToStoreAssets({ csiAssets, contentSourceInstance, defaultLocaleCode }) {
     const extra = {
         srcType: contentSourceInstance.getContentSourceType(),
         srcProjectId: contentSourceInstance.getProjectId(),
         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, defaultLocaleCode, extra }) {
+function sourceAssetToStoreAsset({ csiAsset, defaultLocaleCode, extra }) {
     return {
         type: 'asset',
         ...extra,
-        srcObjectId: asset.id,
-        srcObjectUrl: asset.manageUrl,
-        srcObjectLabel: getObjectLabel(asset.fields, common_schema_1.IMAGE_MODEL, defaultLocaleCode),
+        srcObjectId: csiAsset.id,
+        srcObjectUrl: csiAsset.manageUrl,
+        srcObjectLabel: getObjectLabel(csiAsset.fields, common_schema_1.IMAGE_MODEL, defaultLocaleCode),
         srcModelName: common_schema_1.IMAGE_MODEL.name,
         srcModelLabel: common_schema_1.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, contentSourceInstance, modelMap, defaultLocaleCode }) {
+function mapCSIDocumentsToStoreDocuments({ csiDocuments, contentSourceInstance, modelMap, defaultLocaleCode }) {
     const extra = {
         srcType: contentSourceInstance.getContentSourceType(),
         srcProjectId: contentSourceInstance.getProjectId(),
         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, model, modelMap, defaultLocaleCode, extra }) {
+function mapCSIDocumentToStoreDocument({ csiDocument, model, modelMap, defaultLocaleCode, extra }) {
     var _a, _b;
     return {
         type: 'document',
         ...extra,
-        srcObjectId: document.id,
-        srcObjectUrl: document.manageUrl,
-        srcObjectLabel: getObjectLabel(document.fields, model, defaultLocaleCode),
-        srcModelLabel: (_a = model.label) !== null && _a !== void 0 ? _a : lodash_1.default.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: (_a = model.label) !== null && _a !== void 0 ? _a : lodash_1.default.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: (_b = model.fields) !== null && _b !== void 0 ? _b : [],
             modelMap,
             defaultLocaleCode
         })
     };
 }
-function mapSourceFieldsToStoreFields({ documentFields, modelFields, modelMap, defaultLocaleCode }) {
+function mapCSIFieldsToStoreFields({ csiDocumentFields, modelFields, modelMap, defaultLocaleCode }) {
     return modelFields.reduce((result, modelField) => {
-        const documentField = documentFields[modelField.name];
+        const csiDocumentField = csiDocumentFields[modelField.name];
         const docField = mapSourceFieldToStoreField({
-            documentField,
+            csiDocumentField,
             modelField,
             modelMap,
             defaultLocaleCode
@@ -908,8 +939,8 @@ function mapSourceFieldsToStoreFields({ documentFields, modelFields, modelMap, d
         return result;
     }, {});
 }
-function mapSourceFieldToStoreField({ documentField, modelField, modelMap, defaultLocaleCode }) {
-    if (!documentField) {
+function mapSourceFieldToStoreField({ csiDocumentField, modelField, modelMap, defaultLocaleCode }) {
+    if (!csiDocumentField) {
         const isUnset = ['object', 'model', 'reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(modelField.type);
         return {
             type: modelField.type,
@@ -920,27 +951,27 @@ function mapSourceFieldToStoreField({ documentField, modelField, modelMap, defau
     // TODO: check if need to add "options" to "enum" and subtype/min/max to "number"
     switch (modelField.type) {
         case 'object':
-            return mapObjectField(documentField, modelField, modelMap, defaultLocaleCode);
+            return mapObjectField(csiDocumentField, modelField, modelMap, defaultLocaleCode);
         case 'model':
-            return mapModelField(documentField, modelField, modelMap, defaultLocaleCode);
+            return mapModelField(csiDocumentField, modelField, modelMap, defaultLocaleCode);
         case 'list':
-            return mapListField(documentField, modelField, modelMap, defaultLocaleCode);
+            return mapListField(csiDocumentField, modelField, modelMap, defaultLocaleCode);
         case 'richText':
-            return mapRichTextField(documentField);
+            return mapRichTextField(csiDocumentField);
         case 'markdown':
-            return mapMarkdownField(documentField);
+            return mapMarkdownField(csiDocumentField);
         default:
-            return documentField;
+            return csiDocumentField;
     }
 }
-function mapObjectField(documentField, modelField, modelMap, defaultLocaleCode) {
+function mapObjectField(csiDocumentField, modelField, modelMap, defaultLocaleCode) {
     var _a, _b, _c;
-    if (!(0, content_source_interface_1.isLocalizedField)(documentField)) {
+    if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
         return {
-            type: documentField.type,
-            srcObjectLabel: getObjectLabel((_a = documentField.fields) !== null && _a !== void 0 ? _a : {}, modelField !== null && modelField !== void 0 ? modelField : [], defaultLocaleCode),
-            fields: mapSourceFieldsToStoreFields({
-                documentFields: (_b = documentField.fields) !== null && _b !== void 0 ? _b : {},
+            type: csiDocumentField.type,
+            srcObjectLabel: getObjectLabel((_a = csiDocumentField.fields) !== null && _a !== void 0 ? _a : {}, modelField !== null && modelField !== void 0 ? modelField : [], defaultLocaleCode),
+            fields: mapCSIFieldsToStoreFields({
+                csiDocumentFields: (_b = csiDocumentField.fields) !== null && _b !== void 0 ? _b : {},
                 modelFields: (_c = modelField.fields) !== null && _c !== void 0 ? _c : [],
                 modelMap,
                 defaultLocaleCode
@@ -948,15 +979,15 @@ function mapObjectField(documentField, modelField, modelMap, defaultLocaleCode)
         };
     }
     return {
-        type: documentField.type,
+        type: csiDocumentField.type,
         localized: true,
-        locales: lodash_1.default.mapValues(documentField.locales, (locale) => {
+        locales: lodash_1.default.mapValues(csiDocumentField.locales, (locale) => {
             var _a, _b, _c;
             return {
                 locale: locale.locale,
                 srcObjectLabel: getObjectLabel((_a = locale.fields) !== null && _a !== void 0 ? _a : {}, modelField, locale.locale),
-                fields: mapSourceFieldsToStoreFields({
-                    documentFields: (_b = locale.fields) !== null && _b !== void 0 ? _b : {},
+                fields: mapCSIFieldsToStoreFields({
+                    csiDocumentFields: (_b = locale.fields) !== null && _b !== void 0 ? _b : {},
                     modelFields: (_c = modelField.fields) !== null && _c !== void 0 ? _c : [],
                     modelMap,
                     defaultLocaleCode
@@ -965,17 +996,17 @@ function mapObjectField(documentField, modelField, modelMap, defaultLocaleCode)
         })
     };
 }
-function mapModelField(documentField, modelField, modelMap, defaultLocaleCode) {
+function mapModelField(csiDocumentField, modelField, modelMap, defaultLocaleCode) {
     var _a, _b, _c, _d;
-    if (!(0, content_source_interface_1.isLocalizedField)(documentField)) {
-        const model = modelMap[documentField.modelName];
+    if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
+        const model = modelMap[csiDocumentField.modelName];
         return {
-            type: documentField.type,
-            srcObjectLabel: getObjectLabel((_a = documentField.fields) !== null && _a !== void 0 ? _a : {}, model, defaultLocaleCode),
-            srcModelName: documentField.modelName,
+            type: csiDocumentField.type,
+            srcObjectLabel: getObjectLabel((_a = csiDocumentField.fields) !== null && _a !== void 0 ? _a : {}, model, defaultLocaleCode),
+            srcModelName: csiDocumentField.modelName,
             srcModelLabel: (_b = model.label) !== null && _b !== void 0 ? _b : lodash_1.default.startCase(model.name),
-            fields: mapSourceFieldsToStoreFields({
-                documentFields: (_c = documentField.fields) !== null && _c !== void 0 ? _c : {},
+            fields: mapCSIFieldsToStoreFields({
+                csiDocumentFields: (_c = csiDocumentField.fields) !== null && _c !== void 0 ? _c : {},
                 modelFields: (_d = model.fields) !== null && _d !== void 0 ? _d : [],
                 modelMap,
                 defaultLocaleCode
@@ -983,9 +1014,9 @@ function mapModelField(documentField, modelField, modelMap, defaultLocaleCode) {
         };
     }
     return {
-        type: documentField.type,
+        type: csiDocumentField.type,
         localized: true,
-        locales: lodash_1.default.mapValues(documentField.locales, (locale) => {
+        locales: lodash_1.default.mapValues(csiDocumentField.locales, (locale) => {
             var _a, _b, _c, _d;
             const model = modelMap[locale.modelName];
             return {
@@ -993,8 +1024,8 @@ function mapModelField(documentField, modelField, modelMap, defaultLocaleCode) {
                 srcObjectLabel: getObjectLabel((_a = locale.fields) !== null && _a !== void 0 ? _a : {}, model, locale.locale),
                 srcModelName: locale.modelName,
                 srcModelLabel: (_b = model.label) !== null && _b !== void 0 ? _b : lodash_1.default.startCase(model.name),
-                fields: mapSourceFieldsToStoreFields({
-                    documentFields: (_c = locale.fields) !== null && _c !== void 0 ? _c : {},
+                fields: mapCSIFieldsToStoreFields({
+                    csiDocumentFields: (_c = locale.fields) !== null && _c !== void 0 ? _c : {},
                     modelFields: (_d = model.fields) !== null && _d !== void 0 ? _d : [],
                     modelMap,
                     defaultLocaleCode
@@ -1003,14 +1034,14 @@ function mapModelField(documentField, modelField, modelMap, defaultLocaleCode) {
         })
     };
 }
-function mapListField(documentField, modelField, modelMap, defaultLocaleCode) {
-    if (!(0, content_source_interface_1.isLocalizedField)(documentField)) {
+function mapListField(csiDocumentField, modelField, modelMap, defaultLocaleCode) {
+    if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
         return {
-            type: documentField.type,
-            items: documentField.items.map((item) => {
+            type: csiDocumentField.type,
+            items: csiDocumentField.items.map((item) => {
                 var _a;
                 return mapSourceFieldToStoreField({
-                    documentField: item,
+                    csiDocumentField: item,
                     modelField: (_a = modelField.items) !== null && _a !== void 0 ? _a : { type: 'string' },
                     modelMap,
                     defaultLocaleCode
@@ -1019,16 +1050,16 @@ function mapListField(documentField, modelField, modelMap, defaultLocaleCode) {
         };
     }
     return {
-        type: documentField.type,
+        type: csiDocumentField.type,
         localized: true,
-        locales: lodash_1.default.mapValues(documentField.locales, (locale) => {
+        locales: lodash_1.default.mapValues(csiDocumentField.locales, (locale) => {
             var _a;
             return {
                 locale: locale.locale,
                 items: ((_a = locale.items) !== null && _a !== void 0 ? _a : []).map((item) => {
                     var _a;
                     return mapSourceFieldToStoreField({
-                        documentField: item,
+                        csiDocumentField: item,
                         modelField: (_a = modelField.items) !== null && _a !== void 0 ? _a : { type: 'string' },
                         modelMap,
                         defaultLocaleCode
@@ -1038,17 +1069,17 @@ function mapListField(documentField, modelField, modelMap, defaultLocaleCode) {
         })
     };
 }
-function mapRichTextField(documentField) {
-    if (!(0, content_source_interface_1.isLocalizedField)(documentField)) {
+function mapRichTextField(csiDocumentField) {
+    if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
         return {
-            ...documentField,
+            ...csiDocumentField,
             multiElement: true
         };
     }
     return {
-        type: documentField.type,
+        type: csiDocumentField.type,
         localized: true,
-        locales: lodash_1.default.mapValues(documentField.locales, (locale) => {
+        locales: lodash_1.default.mapValues(csiDocumentField.locales, (locale) => {
             return {
                 ...locale,
                 multiElement: true
@@ -1056,18 +1087,18 @@ function mapRichTextField(documentField) {
         })
     };
 }
-function mapMarkdownField(documentField) {
-    if (!(0, content_source_interface_1.isLocalizedField)(documentField)) {
+function mapMarkdownField(csiDocumentField) {
+    if (!(0, content_source_interface_1.isLocalizedField)(csiDocumentField)) {
         return {
             type: 'markdown',
-            value: documentField.value,
+            value: csiDocumentField.value,
             multiElement: true
         };
     }
     return {
         type: 'markdown',
         localized: true,
-        locales: lodash_1.default.mapValues(documentField.locales, (locale) => {
+        locales: lodash_1.default.mapValues(csiDocumentField.locales, (locale) => {
             return {
                 ...locale,
                 multiElement: true
@@ -1076,7 +1107,7 @@ function mapMarkdownField(documentField) {
     };
 }
 function mapStoreFieldsToSourceFields({ documentFields, modelFields, modelMap }) {
-    // TODO:
+    // TODO: implement
     throw new Error(`duplicateDocument not implemented yet`);
 }
 function getContentSourceIdForContentSource(contentSource) {
@@ -1640,4 +1671,20 @@ function isStackbitConfigFile(filePath) {
     const isMainStackbitConfigFile = pathObject.name === 'stackbit' && ['yaml', 'yml'].includes(pathObject.ext.substring(1));
     return isMainStackbitConfigFile || isInDotStackbitFolder;
 }
+function getCSIDocumentsAndAssetsFromContentSourceDataByIds(contentSourceData, objects) {
+    const documents = [];
+    const assets = [];
+    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
+    };
+}
 //# sourceMappingURL=content-store.js.map