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

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 {
@@ -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;

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

@@ -184,7 +184,7 @@ function mapCSIFieldToStoreField({
     context: MapContext;
 }): ContentStoreTypes.DocumentField {
     if (!csiDocumentField) {
-        const isUnset = ['object', 'model', 'reference', 'cross-reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(modelField.type);
+        const isUnset = ['object', 'model', 'reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(modelField.type);
         return {
             type: modelField.type,
             ...(localized
@@ -223,8 +223,6 @@ function mapCSIFieldToStoreField({
         case 'file':
         case 'reference':
             return csiDocumentField as ContentStoreTypes.DocumentField;
-        case 'cross-reference':
-            return mapReferenceField(csiDocumentField)
         case 'object':
             return mapObjectField(csiDocumentField as CSITypes.DocumentObjectField, modelField, context);
         case 'model':
@@ -243,76 +241,6 @@ function mapCSIFieldToStoreField({
     }
 }
 
-function mapReferenceField(csiDocumentField: CSITypes.DocumentField): ContentStoreTypes.DocumentCrossReferenceField {
-    const unlocalizedUnset = {
-        type: 'cross-reference',
-        refType: 'document',
-        isUnset: true
-    } as const;
-    if (csiDocumentField.type !== 'string' && csiDocumentField.type !== 'text' && csiDocumentField.type !== 'json') {
-        if (isLocalizedField(csiDocumentField)) {
-            return {
-                type: 'cross-reference',
-                refType: 'document',
-                localized: true,
-                locales: {}
-            };
-        }
-        return unlocalizedUnset;
-    }
-    const parseRefObject = (value: any): { refId: string; refSrcType: string; refProjectId: string } | null => {
-        if (typeof value === 'string') {
-            try {
-                value = JSON.parse(value);
-            } catch (error) {
-                return null;
-            }
-        }
-        if (_.isPlainObject(value) && 'refId' in value && 'refSrcType' in value && 'refProjectId' in value) {
-            return {
-                refId: value.refId,
-                refSrcType: value.refSrcType,
-                refProjectId: value.refProjectId
-            };
-        }
-        return null;
-    };
-    if (isLocalizedField(csiDocumentField)) {
-        csiDocumentField.locales;
-        return {
-            type: 'cross-reference',
-            refType: 'document',
-            localized: true,
-            locales: _.reduce(
-                csiDocumentField.locales,
-                (accum: Record<string, { locale: string; refId: string; refSrcType: string; refProjectId: string }>, locale, localeKey) => {
-                    const refObject = parseRefObject(locale.value);
-                    if (refObject) {
-                        accum[localeKey] = {
-                            locale: locale.locale,
-                            ...refObject
-                        };
-                    }
-                    return accum;
-                },
-                {}
-            )
-        };
-    }
-    if (!('value' in csiDocumentField)) {
-        return unlocalizedUnset;
-    }
-    const refObject = parseRefObject(csiDocumentField.value);
-    if (!refObject) {
-        return unlocalizedUnset;
-    }
-    return {
-        type: 'cross-reference',
-        refType: 'document',
-        ...refObject
-    };
-}
-
 function mapObjectField(
     csiDocumentField: CSITypes.DocumentObjectField,
     modelField: FieldObjectProps,
@@ -385,15 +313,14 @@ function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField:
     if (!isLocalizedField(csiDocumentField)) {
         return {
             type: csiDocumentField.type,
-            items: csiDocumentField.items.map(
-                (item) =>
-                    mapCSIFieldToStoreField({
-                        csiDocumentField: item,
-                        modelField: modelField.items ?? { type: 'string' },
-                        // list items can not be localized, only the list itself can be localized
-                        localized: false,
-                        context
-                    }) as ContentStoreTypes.DocumentListFieldItems
+            items: csiDocumentField.items.map((item) =>
+                mapCSIFieldToStoreField({
+                    csiDocumentField: item,
+                    modelField: modelField.items ?? { type: 'string' },
+                    // list items can not be localized, only the list itself can be localized
+                    localized: false,
+                    context
+                }) as ContentStoreTypes.DocumentListFieldItems
             )
         };
     }
@@ -403,15 +330,14 @@ function mapListField(csiDocumentField: CSITypes.DocumentListField, modelField:
         locales: _.mapValues(csiDocumentField.locales, (locale) => {
             return {
                 locale: locale.locale,
-                items: (locale.items ?? []).map(
-                    (item) =>
-                        mapCSIFieldToStoreField({
-                            csiDocumentField: item,
-                            modelField: modelField.items ?? { type: 'string' },
-                            // list items can not be localized, only the list itself can be localized
-                            localized: false,
-                            context
-                        }) as ContentStoreTypes.DocumentListFieldItems
+                items: (locale.items ?? []).map((item) =>
+                    mapCSIFieldToStoreField({
+                        csiDocumentField: item,
+                        modelField: modelField.items ?? { type: 'string' },
+                        // list items can not be localized, only the list itself can be localized
+                        localized: false,
+                        context
+                    }) as ContentStoreTypes.DocumentListFieldItems
                 )
             };
         })

package/src/utils/duplicate-document.ts

@@ -202,9 +202,6 @@ function mergeObjectWithDocumentField({
             }
             break;
         }
-        case 'cross-reference':
-            // TODO: implement duplicating documents with cross-references
-            break;
         case 'list': {
             const localizedField = getDocumentFieldForLocale(documentField, locale);
             if (value) {

package/src/utils/model-utils.ts

@@ -1,18 +1,10 @@
 import _ from 'lodash';
 
-import { FieldCrossReferenceModel, Logger, ModelWithSource } from '@stackbit/types';
-import {
-    Model,
-    assignLabelFieldIfNeeded,
-    isObjectField,
-    isCrossReferenceField,
-    isPageModel,
-    mapModelFieldsRecursively,
-    mapListItemsPropsOrSelfSpecificProps,
-    validateConfig
-} from '@stackbit/sdk';
-
-export function normalizeModels({ models, logger }: { models: ModelWithSource[]; logger: Logger }): ModelWithSource[] {
+import { Logger } from '@stackbit/types';
+import { Model, assignLabelFieldIfNeeded, isObjectField, isPageModel, mapModelFieldsRecursively, mapListItemsPropsOrSelfSpecificProps } from '@stackbit/sdk';
+import { validateConfig } from '@stackbit/sdk';
+
+export function normalizeModels<T extends Model>({ models, logger }: { models: T[]; logger: Logger }): T[] {
     return models.map((model) => {
         model = { ...model };
 
@@ -53,98 +45,18 @@ export function normalizeModels({ models, logger }: { models: ModelWithSource[];
             mapListItemsPropsOrSelfSpecificProps(field, (listItemsPropsOrField) => {
                 if (isObjectField(listItemsPropsOrField)) {
                     assignLabelFieldIfNeeded(listItemsPropsOrField);
-                } else if (isCrossReferenceField(listItemsPropsOrField)) {
-                    listItemsPropsOrField.models = validateAndNormalizeCrossReferenceModels({
-                        crossReferenceModels: listItemsPropsOrField.models,
-                        models,
-                        logger
-                    });
                 }
                 return listItemsPropsOrField;
             });
 
             return field;
-        });
+        }) as T;
 
         return model;
     });
 }
 
-function validateAndNormalizeCrossReferenceModels({
-    crossReferenceModels,
-    models,
-    logger
-}: {
-    crossReferenceModels: FieldCrossReferenceModel[];
-    models: ModelWithSource[];
-    logger: Logger;
-}): FieldCrossReferenceModel[] {
-    const modelGroupsByModelName = models.reduce((modelGroups: Record<string, ModelWithSource[]>, model) => {
-        if (!(model.name in modelGroups)) {
-            modelGroups[model.name] = [];
-        }
-        modelGroups[model.name]!.push(model);
-        return modelGroups;
-    }, {});
-
-    // Match cross-reference models to the group of content source models with
-    // the same name. Then, match the cross-reference model to content source
-    // model by comparing srcType and srcProjectId. If after the comparison,
-    // there are more than one model left, log a warning and filter out that
-    // cross-reference model so it won't cause any model ambiguity.
-    const nonMatchedCrossReferenceModels: {
-        crossReferenceModel: FieldCrossReferenceModel;
-        matchedModels: ModelWithSource[];
-    }[] = [];
-
-    const normalizedCrossReferenceModels = crossReferenceModels.reduce((matchedCrossReferenceModels: FieldCrossReferenceModel[], crossReferenceModel) => {
-        const models = modelGroupsByModelName[crossReferenceModel.modelName];
-        if (!models) {
-            nonMatchedCrossReferenceModels.push({ crossReferenceModel, matchedModels: [] });
-            return matchedCrossReferenceModels;
-        }
-        const matchedModels = models.filter((model) => {
-            const matchesType = !crossReferenceModel.srcType || model.srcType === crossReferenceModel.srcType;
-            const matchesId = !crossReferenceModel.srcProjectId || model.srcProjectId === crossReferenceModel.srcProjectId;
-            return matchesType && matchesId;
-        });
-        if (matchedModels.length !== 1) {
-            nonMatchedCrossReferenceModels.push({ crossReferenceModel, matchedModels });
-            return matchedCrossReferenceModels;
-        }
-        const matchedModel = matchedModels[0]!;
-        matchedCrossReferenceModels.push({
-            modelName: crossReferenceModel.modelName,
-            srcType: matchedModel.srcType,
-            srcProjectId: matchedModel.srcProjectId
-        });
-        return matchedCrossReferenceModels;
-    }, []);
-
-    // Log model matching warnings using user logger
-    for (const { crossReferenceModel, matchedModels } of nonMatchedCrossReferenceModels) {
-        let message = `a model of cross-reference field: '${crossReferenceModel.modelName}'`;
-        if (crossReferenceModel.srcType) {
-            message += `, srcType: '${crossReferenceModel.srcType}'`;
-        }
-        if (crossReferenceModel.srcProjectId) {
-            message += `, srcProjectId: '${crossReferenceModel.srcProjectId}'`;
-        }
-        message = message + ` defined in stackbit config`;
-        let contentSourceModelsMessage;
-        if (matchedModels.length) {
-            const matchesModelsMessage = matchedModels.map((model) => `srcType: '${model.srcType}', srcProjectId: '${model.srcProjectId}'`).join('; ');
-            contentSourceModelsMessage = ` matches more that 1 model in the following content sources: ${matchesModelsMessage}`;
-        } else {
-            contentSourceModelsMessage = ' does not match any content source model';
-        }
-        logger.warn(message + contentSourceModelsMessage);
-    }
-
-    return normalizedCrossReferenceModels;
-}
-
-export function validateModels<T extends Model>({ models, logger }: { models: T[]; logger: Logger }): T[] {
+export function validateModels<T extends Model>({ models, logger }: { models: T[], logger: Logger }): T[] {
     const { config, errors } = validateConfig({
         stackbitVersion: '0.5.0',
         models: models,