@stackbit/cms-core 0.1.20-cross-references.0 → 0.1.20

package/src/content-store.ts

@@ -32,8 +32,7 @@ import {
     getModelFieldForFieldAtPath,
     getUserContextForSrcType,
     groupDocumentsByContentSource,
-    groupModelsByContentSource,
-    updateOperationValueFieldWithCrossReference
+    groupModelsByContentSource
 } from './content-store-utils';
 import {
     getSiteMapEntriesFromStackbitConfig,
@@ -201,7 +200,7 @@ export class ContentStore {
         this.contentUpdatesWatchTimer.stopTimer();
     }
 
-    async onFilesChange(updatedFiles: string[]): Promise<{ schemaChanged?: boolean; contentChanges: ContentStoreTypes.ContentChangeResult }> {
+    async onFilesChange(updatedFiles: string[]): Promise<void> {
         this.logger.debug('onFilesChange');
 
         let schemaChanged = false;
@@ -249,20 +248,15 @@ export class ContentStore {
             }
         }
 
-        let contentChanges: ContentStoreTypes.ContentChangeResult = {
-            updatedDocuments: [],
-            updatedAssets: [],
-            deletedDocuments: [],
-            deletedAssets: []
-        };
-
         // If the schema was changed, there is no need to accumulate or notify about content changes.
         // The processData will update the store with the latest data. And once the Studio receives
         // the schemaChanged notification it will reload all the models and the documents with their latest state.
         if (schemaChanged) {
             await this.loadContentSourcesAndProcessData({ init: false, contentSourceIds: contentSourceIdsWithChangedSchema });
+
+            this.onSchemaChangeCallback();
         } else {
-            contentChanges = contentChangeEvents.reduce((contentChanges, { contentSourceId, contentChangeEvent }) => {
+            const contentChanges = contentChangeEvents.reduce((contentChanges: ContentStoreTypes.ContentChangeResult, { contentSourceId, contentChangeEvent }) => {
                 const contentChangeResult = this.onContentChange(contentSourceId, contentChangeEvent);
                 return {
                     updatedDocuments: contentChanges.updatedDocuments.concat(contentChangeResult.updatedDocuments),
@@ -270,7 +264,12 @@ export class ContentStore {
                     deletedDocuments: contentChanges.deletedDocuments.concat(contentChangeResult.deletedDocuments),
                     deletedAssets: contentChanges.deletedAssets.concat(contentChangeResult.deletedAssets)
                 };
-            }, contentChanges);
+            }, {
+                updatedDocuments: [],
+                updatedAssets: [],
+                deletedDocuments: [],
+                deletedAssets: []
+            });
 
             this.siteMapEntryGroups = await updateSiteMapEntriesWithContentChanges({
                 siteMapEntryGroups: this.siteMapEntryGroups,
@@ -278,14 +277,9 @@ export class ContentStore {
                 stackbitConfig: this.stackbitConfig,
                 contentSourceDataById: this.contentSourceDataById
             });
-        }
 
-        // TODO: maybe instead of returning object with results
-        //  replace with this.onSchemaChangeCallback() and this.onContentChangeCallback(contentChanges) for consistency of data flow?
-        return {
-            schemaChanged: schemaChanged,
-            contentChanges: contentChanges
-        };
+            this.onContentChangeCallback(contentChanges);
+        }
     }
 
     private async loadYamlModels({ stackbitConfig }: { stackbitConfig: Config }): Promise<Model[]> {
@@ -1180,8 +1174,6 @@ export class ContentStore {
         srcDocumentId,
         fieldPath,
         modelName,
-        refSrcType,
-        refProjectId,
         object,
         index,
         locale,
@@ -1192,14 +1184,12 @@ export class ContentStore {
         srcDocumentId: string;
         fieldPath: (string | number)[];
         modelName?: string;
-        refSrcType?: string;
-        refProjectId?: string;
         object?: Record<string, any>;
         index?: number;
         locale?: string;
         user?: ContentStoreTypes.User;
-    }): Promise<{ srcDocumentId: string; createdDocumentId: string }> {
-        this.logger.debug('createAndLinkDocument', { srcType, srcProjectId, srcDocumentId, fieldPath, modelName, refSrcType, refProjectId, index, locale });
+    }): Promise<{ srcDocumentId: string, createdDocumentId: string }> {
+        this.logger.debug('createAndLinkDocument', { srcType, srcProjectId, srcDocumentId, fieldPath, modelName, index, locale });
 
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
@@ -1213,51 +1203,36 @@ export class ContentStore {
 
         // get the document model
         const documentModelName = document.srcModelName;
-        const modelMap = contentSourceData.modelMap;
-        const model = modelMap[documentModelName];
         const csiModelMap = contentSourceData.csiModelMap;
         const csiModel = csiModelMap[documentModelName];
-        if (!model || !csiModel) {
+        if (!csiModel) {
             throw new Error(`error updating document, could not find document model: '${documentModelName}'`);
         }
 
         // get the 'reference' model field in the updated document that will be used to link the new document
         locale = locale ?? contentSourceData.defaultLocaleCode;
-        const modelField = getModelFieldForFieldAtPath(document, model, fieldPath, modelMap, locale);
         const csiModelField = getModelFieldForFieldAtPath(document, csiModel, fieldPath, csiModelMap, locale);
-        if (!modelField || !csiModelField) {
+        if (!csiModelField) {
             throw Error(`the "fieldPath" points to non existing model field: ${fieldPath.join('.')}`);
         }
-        const fieldProps = modelField.type === 'list' ? modelField.items! : modelField;
-        const csiFieldProps = csiModelField.type === 'list' ? csiModelField.items! : csiModelField;
-        if (fieldProps.type !== 'reference' && fieldProps.type !== 'cross-reference') {
+        const fieldProps = csiModelField.type === 'list' ? csiModelField.items! : csiModelField;
+        if (fieldProps.type !== 'reference') {
             throw Error(`error in "createAndLinkDocument", this operation can only be used on reference field: ${fieldPath.join('.')}`);
         }
 
         // get the model name for the new document
         if (!modelName && fieldProps.models.length === 1) {
-            if (fieldProps.type === 'reference') {
-                modelName = fieldProps.models[0];
-            } else if (fieldProps.type === 'cross-reference') {
-                modelName = fieldProps.models[0]!.modelName;
-            }
+            modelName = fieldProps.models[0];
         }
         if (!modelName) {
             throw Error(`error in "createAndLinkDocument", missing "modelName": ${fieldPath.join('.')}`);
         }
 
-        if (fieldProps.type === 'reference') {
-            refSrcType = srcType;
-            refProjectId = srcProjectId;
-        } else if (!refSrcType || !refProjectId) {
-            throw Error(`the "refSrcType" and "refProjectId" must be specified when linking a cross-reference field: ${fieldPath.join('.')}`);
-        }
-
         // create the new document
         const result = await this.createDocument({
             object: object,
-            srcProjectId: refProjectId,
-            srcType: refSrcType,
+            srcProjectId: srcProjectId,
+            srcType: srcType,
             modelName: modelName,
             locale: locale,
             user: user
@@ -1265,29 +1240,17 @@ export class ContentStore {
 
         // update the document by linking the field to the created document
         const userContext = getUserContextForSrcType(srcType, user);
-        let field: CSITypes.UpdateOperationField;
-        if (fieldProps.type === 'reference') {
-            field = {
-                type: 'reference',
-                refType: 'document',
-                refId: result.srcDocumentId
-            } as CSITypes.UpdateOperationReferenceField;
-        } else {
-            if (!['string', 'text', 'json'].includes(csiFieldProps.type)) {
-                throw new Error(`The 'cross-reference' field can be only applied on string, text and json fields: ${fieldPath.join('.')}`);
-            }
-            field = updateOperationValueFieldWithCrossReference(csiFieldProps.type as 'string' | 'text' | 'json', {
-                refId: result.srcDocumentId,
-                refSrcType: refSrcType,
-                refProjectId: refProjectId
-            });
-        }
+        const field = {
+            type: 'reference',
+            refType: 'document',
+            refId: result.srcDocumentId
+        } as const;
         const updatedDocument = await contentSourceData.instance.updateDocument({
             document: csiDocument,
             modelMap: csiModelMap,
             userContext: userContext,
             operations: [
-                modelField.type === 'list'
+                csiModelField.type === 'list'
                     ? {
                           opType: 'insert',
                           fieldPath: fieldPath,
@@ -1463,7 +1426,7 @@ export class ContentStore {
         object,
         locale,
         defaultLocaleDocumentId,
-        user
+        user,
     }: {
         srcType: string;
         srcProjectId: string;
@@ -1477,17 +1440,22 @@ export class ContentStore {
 
         const contentSourceId = getContentSourceId(srcType, srcProjectId);
         const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
+        const modelMap = contentSourceData.modelMap;
+        const csiModelMap = contentSourceData.csiModelMap;
+        const userContext = getUserContextForSrcType(srcType, user);
         const resolvedLocale = locale ?? contentSourceData.defaultLocaleCode;
 
         const result = await createDocumentRecursively({
             object,
             modelName,
-            contentSourceId,
-            contentSourceDataById: this.contentSourceDataById,
+            modelMap,
+            csiModelMap,
             createDocument: getCreateDocumentThunk({
                 locale: resolvedLocale,
+                csiModelMap,
+                userContext,
                 defaultLocaleDocumentId,
-                user
+                contentSourceInstance: contentSourceData.instance
             })
         });
 
@@ -1550,11 +1518,11 @@ export class ContentStore {
                             csiModelField,
                             modelMap,
                             csiModelMap,
-                            contentSourceId,
-                            contentSourceDataById: this.contentSourceDataById,
                             createDocument: getCreateDocumentThunk({
                                 locale: updateOperation.locale,
-                                user
+                                csiModelMap,
+                                userContext,
+                                contentSourceInstance: contentSourceData.instance
                             })
                         });
                         return {
@@ -1578,11 +1546,11 @@ export class ContentStore {
                             csiModelField: csiModelField.items,
                             modelMap,
                             csiModelMap,
-                            contentSourceId,
-                            contentSourceDataById: this.contentSourceDataById,
                             createDocument: getCreateDocumentThunk({
                                 locale: updateOperation.locale,
-                                user
+                                csiModelMap,
+                                userContext,
+                                contentSourceInstance: contentSourceData.instance
                             })
                         });
                         return {
@@ -1649,6 +1617,7 @@ export class ContentStore {
             throw new Error(`no model with name '${document.srcModelName}' was found`);
         }
 
+        const userContext = getUserContextForSrcType(srcType, user);
         const resolvedLocale = locale ?? contentSourceData.defaultLocaleCode;
 
         const extendedObject = mergeObjectWithDocument({
@@ -1664,11 +1633,13 @@ export class ContentStore {
         const result = await createDocumentRecursively({
             object: extendedObject,
             modelName: model.name,
-            contentSourceId,
-            contentSourceDataById: this.contentSourceDataById,
+            modelMap,
+            csiModelMap,
             createDocument: getCreateDocumentThunk({
                 locale: resolvedLocale,
-                user
+                csiModelMap,
+                userContext,
+                contentSourceInstance: contentSourceData.instance
             })
         });
 

package/src/utils/create-update-csi-docs.ts

@@ -7,41 +7,41 @@ import { fieldPathToString, mapPromise } from '@stackbit/utils';
 import * as CSITypes from '@stackbit/types';
 
 import * as ContentStoreTypes from '../content-store-types';
-import { getContentSourceId, getUserContextForSrcType, updateOperationValueFieldWithCrossReference } from '../content-store-utils';
 
 export type CreateDocumentCallback = ({
     updateOperationFields,
-    contentSourceData,
     modelName
 }: {
     updateOperationFields: Record<string, CSITypes.UpdateOperationField>;
-    contentSourceData: ContentStoreTypes.ContentSourceData;
     modelName: string;
 }) => Promise<CSITypes.Document>;
 
 export function getCreateDocumentThunk({
+    csiModelMap,
     locale,
     defaultLocaleDocumentId,
-    user
+    userContext,
+    contentSourceInstance
 }: {
+    csiModelMap: Record<string, CSIModel>;
     locale?: string;
     defaultLocaleDocumentId?: string;
-    user?: ContentStoreTypes.User;
+    userContext: unknown;
+    contentSourceInstance: CSITypes.ContentSourceInterface;
 }): CreateDocumentCallback {
-    return async ({ updateOperationFields, modelName, contentSourceData }) => {
+    return async ({ updateOperationFields, modelName }) => {
         // When passing model and modelMap to contentSourceInstance, we have to pass
         // the original models (i.e., csiModel and csiModelMap) that we've received
         // from that contentSourceInstance. We can't pass internal models as they
         // might
-        const csiModel = contentSourceData.csiModelMap[modelName];
+        const csiModel = csiModelMap[modelName];
         if (!csiModel) {
             throw new Error(`no model with name '${modelName}' was found`);
         }
-        const userContext = getUserContextForSrcType(contentSourceData.srcType, user);
-        return await contentSourceData.instance.createDocument({
+        return await contentSourceInstance.createDocument({
             updateOperationFields: updateOperationFields,
             model: csiModel,
-            modelMap: contentSourceData.csiModelMap,
+            modelMap: csiModelMap,
             locale,
             defaultLocaleDocumentId,
             userContext
@@ -90,24 +90,18 @@ export function getCreateDocumentThunk({
 export async function createDocumentRecursively({
     object,
     modelName,
-    contentSourceId,
-    contentSourceDataById,
+    modelMap,
+    csiModelMap,
     createDocument
 }: {
     object?: Record<string, any>;
     modelName: string;
-    contentSourceId: string;
-    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
+    modelMap: Record<string, SDKModel>;
+    csiModelMap: Record<string, CSIModel>;
     createDocument: CreateDocumentCallback;
 }): Promise<{ document: CSITypes.Document; newRefDocuments: CSITypes.Document[] }> {
-    const contentSourceData = contentSourceDataById[contentSourceId];
-    if (!contentSourceData) {
-        throw new Error(`no content source data for id '${contentSourceId}'`);
-    }
-    const modelMap = contentSourceData.modelMap;
-    const csiModelMap = contentSourceData.csiModelMap;
     const model = modelMap[modelName];
-    const csiModel = contentSourceData.csiModelMap[modelName];
+    const csiModel = csiModelMap[modelName];
     if (!model || !csiModel) {
         throw new Error(`no model with name '${modelName}' was found`);
     }
@@ -127,14 +121,11 @@ export async function createDocumentRecursively({
         fieldPath: [modelName],
         modelMap,
         csiModelMap,
-        contentSourceId,
-        contentSourceDataById,
         createDocument
     });
 
     const document = await createDocument({
         updateOperationFields: nestedResult.fields,
-        contentSourceData: contentSourceData,
         modelName: modelName
     });
     return {
@@ -161,8 +152,6 @@ async function createObjectRecursively({
     fieldPath,
     modelMap,
     csiModelMap,
-    contentSourceId,
-    contentSourceDataById,
     createDocument
 }: {
     object?: Record<string, any>;
@@ -171,8 +160,6 @@ async function createObjectRecursively({
     fieldPath: (string | number)[];
     modelMap: Record<string, SDKModel>;
     csiModelMap: Record<string, CSIModel>;
-    contentSourceId: string;
-    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
     createDocument: CreateDocumentCallback;
 }): Promise<{
     fields: Record<string, CSITypes.UpdateOperationField>;
@@ -219,8 +206,6 @@ async function createObjectRecursively({
                 fieldPath: fieldPath.concat(fieldName),
                 modelMap,
                 csiModelMap,
-                contentSourceId,
-                contentSourceDataById,
                 createDocument
             });
             result.fields[fieldName] = fieldResult.field;
@@ -241,8 +226,6 @@ async function createUpdateOperationFieldRecursively({
     fieldPath,
     modelMap,
     csiModelMap,
-    contentSourceId,
-    contentSourceDataById,
     createDocument
 }: {
     value: any;
@@ -251,8 +234,6 @@ async function createUpdateOperationFieldRecursively({
     fieldPath: (string | number)[];
     modelMap: Record<string, SDKModel>;
     csiModelMap: Record<string, CSIModel>;
-    contentSourceId: string;
-    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
     createDocument: CreateDocumentCallback;
 }): Promise<{ field: CSITypes.UpdateOperationField; newRefDocuments: CSITypes.Document[] }> {
     if (csiModelField.type === 'object') {
@@ -266,8 +247,6 @@ async function createUpdateOperationFieldRecursively({
             fieldPath,
             modelMap,
             csiModelMap,
-            contentSourceId,
-            contentSourceDataById,
             createDocument
         });
         return {
@@ -305,8 +284,6 @@ async function createUpdateOperationFieldRecursively({
             fieldPath,
             modelMap,
             csiModelMap,
-            contentSourceId,
-            contentSourceDataById,
             createDocument
         });
         return {
@@ -322,7 +299,7 @@ async function createUpdateOperationFieldRecursively({
         // TODO: if modelField.source is cloudinary, the new document field
         //  should be of the 'image' type with 'title' and 'url' properties
         if (_.isPlainObject(value)) {
-            refId = value.$$ref;
+            refId = value.$$ref ?? value.url;
         } else {
             refId = value;
         }
@@ -363,14 +340,11 @@ async function createUpdateOperationFieldRecursively({
                     modelName = modelNames[0];
                 }
             }
-            if (!modelName) {
-                throw new Error('reference field type must have $$type or $$ref properties when creating new documents');
-            }
             const { document, newRefDocuments } = await createDocumentRecursively({
                 object: rest,
                 modelName,
-                contentSourceId,
-                contentSourceDataById,
+                modelMap,
+                csiModelMap,
                 createDocument
             });
             return {
@@ -382,39 +356,6 @@ async function createUpdateOperationFieldRecursively({
                 newRefDocuments: [document, ...newRefDocuments]
             };
         }
-    } else if (['string', 'text', 'json'].includes(csiModelField.type) && modelField.type === 'cross-reference') {
-        const fieldType = csiModelField.type as 'string' | 'text' | 'json';
-        let { $$ref: refId = null, $$type: modelName = null, $$refSrcType: refSrcType = null, $$refProjectId: refProjectId = null, ...rest } = value;
-        let refObject;
-        const newRefDocuments: CSITypes.Document[] = [];
-        if (refId && refSrcType && refProjectId) {
-            refObject = { refId, refSrcType, refProjectId };
-        } else {
-            if (!modelName || !refSrcType || !refProjectId) {
-                const models = modelField.models;
-                if (models && models.length === 1) {
-                    modelName = models[0]!.modelName;
-                    refSrcType = models[0]!.srcType;
-                    refProjectId = models[0]!.srcProjectId;
-                }
-            }
-            if (!modelName || !refSrcType || !refProjectId) {
-                throw new Error('reference field type must have $$type or $$ref properties when creating new documents');
-            }
-            const { document, newRefDocuments } = await createDocumentRecursively({
-                object: rest,
-                modelName,
-                contentSourceId: getContentSourceId(refSrcType, refProjectId),
-                contentSourceDataById,
-                createDocument
-            });
-            newRefDocuments.push(document, ...newRefDocuments);
-            refObject = { refId: document.id, refSrcType, refProjectId };
-        }
-        return {
-            field: updateOperationValueFieldWithCrossReference(fieldType, refObject),
-            newRefDocuments
-        };
     } else if (csiModelField.type === 'list') {
         if (modelField.type !== 'list') {
             throw new Error(`field type mismatch between external and internal models at field path ${fieldPathToString(fieldPath)}`);
@@ -437,8 +378,6 @@ async function createUpdateOperationFieldRecursively({
                     fieldPath: fieldPath.concat(index),
                     modelMap,
                     csiModelMap,
-                    contentSourceId,
-                    contentSourceDataById,
                     createDocument
                 });
                 if (result.field.type === 'list') {
@@ -486,8 +425,6 @@ export async function convertOperationField({
     csiModelField,
     modelMap,
     csiModelMap,
-    contentSourceId,
-    contentSourceDataById,
     createDocument
 }: {
     operationField: ContentStoreTypes.UpdateOperationField;
@@ -496,8 +433,6 @@ export async function convertOperationField({
     csiModelField: FieldSpecificProps;
     modelMap: Record<string, SDKModel>;
     csiModelMap: Record<string, SDKModel>;
-    contentSourceId: string;
-    contentSourceDataById: Record<string, ContentStoreTypes.ContentSourceData>;
     createDocument: CreateDocumentCallback;
 }): Promise<CSITypes.UpdateOperationField> {
     switch (operationField.type) {
@@ -512,8 +447,6 @@ export async function convertOperationField({
                 fieldPath,
                 modelMap,
                 csiModelMap,
-                contentSourceId,
-                contentSourceDataById,
                 createDocument
             });
             return {
@@ -534,8 +467,6 @@ export async function convertOperationField({
                 fieldPath,
                 modelMap,
                 csiModelMap,
-                contentSourceId,
-                contentSourceDataById,
                 createDocument
             });
             return {
@@ -545,23 +476,7 @@ export async function convertOperationField({
             };
         }
         case 'reference':
-            // ContentStore and CSI 'reference' operation field have the same format
             return operationField;
-        case 'cross-reference':
-            if (csiModelField.type !== 'string' && csiModelField.type !== 'text' && csiModelField.type !== 'json') {
-                throw new Error(
-                    `update operation with with 'cross-reference' field can be performed on 'string', 'text' and 'json' content-source field types only, got '${csiModelField.type}'`
-                );
-            }
-            const refObject = {
-                refId: operationField.refId,
-                refSrcType: operationField.refSrcType,
-                refProjectId: operationField.refProjectId
-            };
-            return {
-                type: csiModelField.type,
-                value: csiModelField.type === 'json' ? refObject : JSON.stringify(refObject)
-            };
         case 'list': {
             if (modelField.type !== 'list' || csiModelField.type !== 'list') {
                 throw new Error(`the operation field type '${operationField.type}' does not match the model field type '${modelField.type}'`);
@@ -576,8 +491,6 @@ export async function convertOperationField({
                         fieldPath: fieldPath.concat(index),
                         modelMap,
                         csiModelMap,
-                        contentSourceId,
-                        contentSourceDataById,
                         createDocument
                     });
                     if (result.field.type === 'list') {
@@ -593,9 +506,7 @@ export async function convertOperationField({
         }
         case 'enum':
             if (csiModelField.type !== 'enum' && csiModelField.type !== 'string') {
-                throw new Error(
-                    `update operation with 'enum' field can be performed on 'string' and 'enum' content-source field types only, got '${csiModelField.type}'`
-                );
+                throw new Error(`the operation field type 'enum' can be performed on 'string' and 'enum' content-source field types '${csiModelField.type}'`);
             }
             // When inserting new enum value into a list, the client does not
             // send value. Set first option as the value.
@@ -632,8 +543,6 @@ export async function convertOperationField({
                 fieldPath,
                 modelMap,
                 csiModelMap,
-                contentSourceId,
-                contentSourceDataById,
                 createDocument
             });
             return result.field;