@stackbit/cms-sanity 0.2.44-staging.2 → 0.2.45-develop.2

package/src/sanity-document-converter.ts

@@ -1,8 +1,9 @@
 import _ from 'lodash';
 import { SanityDocument } from '@sanity/client';
-import * as ContentSourceTypes from '@stackbit/types';
+import * as StackbitTypes from '@stackbit/types';
 import { DocumentHistory, DocumentHistoryMap } from './sanity-api-client';
-import { ScheduledAction, ScheduledActionState } from '@stackbit/types';
+import { SchemaContext, ModelWithContext, ModelContext } from './sanity-schema-converter';
+import { getItemTypeForListItem, isLocalizedModelField, resolvedFieldType } from './utils';
 
 export interface SanitySchedule {
     author: string;
@@ -34,12 +35,12 @@ export type DocumentContext = {
 
 export type AssetContext = DocumentContext;
 
-export type ContextualDocument = ContentSourceTypes.Document<DocumentContext>;
-export type ContextualAsset = ContentSourceTypes.Asset<AssetContext>;
+export type ContextualDocument = StackbitTypes.Document<DocumentContext>;
+export type ContextualAsset = StackbitTypes.Asset<AssetContext>;
 
 export const DRAFT_ID_PREFIX = 'drafts.';
 
-export type GetModelByName = ContentSourceTypes.Cache['getModelByName'];
+export type GetModelByName = StackbitTypes.Cache<SchemaContext, DocumentContext, AssetContext, ModelContext>['getModelByName'];
 
 export type ConvertDocumentsOptions = {
     documents: SanityDocument[];
@@ -60,11 +61,11 @@ export function isDraftId(objectId: string) {
     return objectId && objectId.startsWith(DRAFT_ID_PREFIX);
 }
 
-export function convertAndFilterScheduledActions(sanitySchedules: SanitySchedule[]): ContentSourceTypes.ScheduledAction[] {
+export function convertAndFilterScheduledActions(sanitySchedules: SanitySchedule[]): StackbitTypes.ScheduledAction[] {
     const allScheduledActions = sanitySchedules.map((schedule: SanitySchedule) => convertScheduledAction(schedule));
     return filterScheduledActions(allScheduledActions);
 }
-export function convertScheduledAction(sanitySchedule: SanitySchedule): ContentSourceTypes.ScheduledAction {
+export function convertScheduledAction(sanitySchedule: SanitySchedule): StackbitTypes.ScheduledAction {
     return {
         id: sanitySchedule.id,
         name: sanitySchedule.name,
@@ -77,12 +78,12 @@ export function convertScheduledAction(sanitySchedule: SanitySchedule): ContentS
     };
 }
 
-export function filterScheduledActions(scheduledActions: ScheduledAction[]) {
+export function filterScheduledActions(scheduledActions: StackbitTypes.ScheduledAction[]) {
     const cutoffDate = new Date();
     cutoffDate.setMonth(cutoffDate.getMonth() - 1);
     const cutoffDateStr = cutoffDate.toISOString();
     return scheduledActions.filter(
-        (scheduledAction: ScheduledAction) => scheduledAction.state !== 'cancelled' && scheduledAction.executeAt.localeCompare(cutoffDateStr) > 0
+        (scheduledAction: StackbitTypes.ScheduledAction) => scheduledAction.state !== 'cancelled' && scheduledAction.executeAt.localeCompare(cutoffDateStr) > 0
     );
 }
 
@@ -144,6 +145,8 @@ function convertDocument({
         fields: convertFields({
             object: document,
             modelFields: model.fields,
+            rootModel: model,
+            modelFieldPath: [],
             getModelByName
         }),
         context: {
@@ -202,13 +205,15 @@ export function convertAssets({ assets, documentsHistory }: ConvertAssetsOptions
 
 export type ConvertFieldsOptions = {
     object: Record<string, any>;
-    modelFields?: ContentSourceTypes.Field[];
+    modelFields?: StackbitTypes.Field[];
+    rootModel: ModelWithContext;
+    modelFieldPath: string[];
     getModelByName: GetModelByName;
 };
 
-function convertFields({ object, modelFields, getModelByName }: ConvertFieldsOptions): Record<string, ContentSourceTypes.DocumentField> {
+function convertFields({ object, modelFields, rootModel, modelFieldPath, getModelByName }: ConvertFieldsOptions): Record<string, StackbitTypes.DocumentField> {
     const fieldsByName = _.keyBy(modelFields, 'name');
-    const result: Record<string, ContentSourceTypes.DocumentField> = {};
+    const result: Record<string, StackbitTypes.DocumentField> = {};
     for (const fieldName in fieldsByName) {
         const value = object[fieldName];
         const modelField = fieldsByName[fieldName];
@@ -218,6 +223,8 @@ function convertFields({ object, modelFields, getModelByName }: ConvertFieldsOpt
         const field = convertFieldType({
             value,
             modelField,
+            rootModel,
+            modelFieldPath: modelFieldPath.concat(fieldName),
             getModelByName
         });
         if (field) {
@@ -227,13 +234,41 @@ function convertFields({ object, modelFields, getModelByName }: ConvertFieldsOpt
     return result;
 }
 
-interface ConvertFieldTypeOptions {
+/**
+ * Converts Sanity's document or object field value, or list item value, to
+ * Stackbit's DocumentField or DocumentListFieldItems.
+ *
+ * The convertFieldType has two overloads:
+ * When modelField is Field, it returns DocumentField or undefined.
+ * When modelField is FieldListItems it returns DocumentListFieldItems or undefined.
+ */
+function convertFieldType(options: {
     value: any;
-    modelField: ContentSourceTypes.Field | ContentSourceTypes.FieldSpecificProps;
+    modelField: StackbitTypes.Field;
+    rootModel: ModelWithContext;
+    modelFieldPath: string[];
     getModelByName: GetModelByName;
-}
-
-function convertFieldType({ value, modelField, getModelByName }: ConvertFieldTypeOptions): ContentSourceTypes.DocumentField | null {
+}): StackbitTypes.DocumentField | undefined;
+function convertFieldType(options: {
+    value: any;
+    modelField: StackbitTypes.FieldListItems;
+    rootModel: ModelWithContext;
+    modelFieldPath: string[];
+    getModelByName: GetModelByName;
+}): StackbitTypes.DocumentListFieldItems | undefined;
+function convertFieldType({
+    value,
+    modelField,
+    rootModel,
+    modelFieldPath,
+    getModelByName
+}: {
+    value: any;
+    modelField: StackbitTypes.Field | StackbitTypes.FieldListItems;
+    rootModel: ModelWithContext;
+    modelFieldPath: string[];
+    getModelByName: GetModelByName;
+}): StackbitTypes.DocumentField | undefined {
     switch (modelField.type) {
         case 'string':
         case 'text':
@@ -246,154 +281,246 @@ function convertFieldType({ value, modelField, getModelByName }: ConvertFieldTyp
         case 'enum':
         case 'json':
         case 'style':
-        case 'cross-reference':
-        case 'markdown':
-            if (_.isUndefined(value)) {
-                return null;
-            }
-            return {
-                value,
-                type: modelField.type
-            } as ContentSourceTypes.DocumentField;
+        case 'markdown': {
+            return createDocumentField({
+                fieldValue: value,
+                modelField: modelField,
+                documentFieldBaseProps: { type: modelField.type },
+                documentFieldSpecificProps: (value: any) => {
+                    if (_.isUndefined(value)) {
+                        return undefined;
+                    }
+                    return { value };
+                }
+            });
+        }
+        case 'cross-reference': {
+            return undefined;
+        }
         case 'list': {
-            const itemsModel = modelField.items ?? { type: 'string' };
-            let getListItemModel: (listItem: any, fieldModel: any) => ContentSourceTypes.FieldListItems | null;
-            if (_.isArray(itemsModel)) {
-                // in Sanity, list items may have multiple types, in this case, 'items' will be an array
-                getListItemModel = (listItem: any, fieldModel: FieldListMultiItem) => getItemTypeForListItem(listItem, fieldModel);
-            } else {
-                getListItemModel = () => itemsModel;
-            }
-            return {
-                type: 'list',
-                items: _.reduce(
-                    value,
-                    (accum: ContentSourceTypes.DocumentListFieldItems[], item) => {
-                        const itemModel = getListItemModel(item, modelField);
-                        if (!itemModel) {
-                            return accum;
-                        }
-                        const documentField = convertFieldType({
-                            value: item,
-                            modelField: itemModel,
+            return createDocumentField({
+                fieldValue: value,
+                modelField: modelField,
+                documentFieldBaseProps: { type: 'list' },
+                documentFieldSpecificProps: (value: any) => {
+                    return {
+                        items: _.reduce(
+                            value,
+                            (accum: StackbitTypes.DocumentListFieldItems[], item) => {
+                                const itemModel = getItemTypeForListItem(item, modelField);
+                                if (!itemModel) {
+                                    return accum;
+                                }
+                                const documentField = convertFieldType({
+                                    value: item,
+                                    modelField: itemModel,
+                                    rootModel,
+                                    modelFieldPath: modelFieldPath.concat('items'),
+                                    getModelByName
+                                });
+                                if (!documentField) {
+                                    return accum;
+                                }
+                                return accum.concat(documentField);
+                            },
+                            []
+                        )
+                    };
+                }
+            });
+        }
+        case 'object': {
+            return createDocumentField({
+                fieldValue: value,
+                modelField: modelField,
+                documentFieldBaseProps: { type: 'object' },
+                documentFieldSpecificProps: (value: any) => {
+                    if (!value) {
+                        return undefined;
+                    }
+                    return {
+                        fields: convertFields({
+                            object: value,
+                            modelFields: modelField.fields,
+                            rootModel,
+                            modelFieldPath,
                             getModelByName
-                        }) as ContentSourceTypes.DocumentListFieldItems;
-                        if (!documentField) {
-                            return accum;
-                        }
-                        return accum.concat(documentField);
-                    },
-                    []
-                )
-            };
+                        })
+                    };
+                }
+            });
         }
-        case 'object':
-            if (!value) {
-                return null;
-            }
-            return {
-                type: 'object',
-                fields: convertFields({ object: value, modelFields: modelField.fields, getModelByName })
-            };
         case 'model': {
-            if (!value) {
-                return null;
-            }
-            const model = getModelByName(value._type);
-            if (!model) {
-                return null;
-            }
-            return {
-                type: 'model',
-                modelName: model.name,
-                fields: convertFields({
-                    object: value,
-                    modelFields: model.fields,
-                    getModelByName
-                })
-            };
+            return createDocumentField({
+                fieldValue: value,
+                modelField: modelField,
+                documentFieldBaseProps: { type: 'model' },
+                documentFieldSpecificProps: (value: any) => {
+                    if (!value) {
+                        return undefined;
+                    }
+                    const modelName = resolvedFieldType({ sanityFieldType: value._type, model: rootModel, modelFieldPath });
+                    const model = getModelByName(modelName);
+                    if (!model) {
+                        return undefined;
+                    }
+                    return {
+                        modelName: model.name,
+                        fields: convertFields({
+                            object: value,
+                            modelFields: model.fields,
+                            rootModel: model,
+                            modelFieldPath: [],
+                            getModelByName
+                        })
+                    };
+                }
+            });
         }
         case 'reference': {
-            if (!value) {
-                return null;
-            }
-            let refId = _.get(value, '_ref', null);
-            if (refId) {
-                refId = refId.replace(/^drafts\./, '');
-            }
-            return {
-                type: 'reference',
-                refType: 'document',
-                refId
-            };
+            return createDocumentField({
+                fieldValue: value,
+                modelField: modelField,
+                documentFieldBaseProps: {
+                    type: 'reference',
+                    refType: 'document'
+                },
+                documentFieldSpecificProps: (value: any) => {
+                    if (!value) {
+                        return undefined;
+                    }
+                    let refId = _.get(value, '_ref', null);
+                    if (refId) {
+                        refId = refId.replace(/^drafts\./, '');
+                    }
+                    return {
+                        refId
+                    };
+                }
+            });
         }
-        case 'color':
-            if (!value) {
-                return null;
-            }
-            return {
-                type: 'color',
-                value: _.get(value, 'hex')
-            };
-        case 'richText':
-            if (!value) {
-                return null;
-            }
-            return {
-                value: null,
-                type: 'richText',
-                hint: flattenRichText(value).substring(0, 200)
-            };
-        case 'image':
-            if (!value) {
-                return null;
-            }
-            if (modelField.source === 'cloudinary' || modelField.source === 'aprimo') {
-                return {
-                    type: 'image',
-                    source: modelField.source,
-                    sourceData: value
-                };
-            }
-            if (modelField.source === 'bynder') {
-                return {
-                    type: 'image',
-                    source: modelField.source,
-                    sourceData: value,
-                    fields: {
-                        title: {
-                            type: 'string',
-                            value: value?.name
-                        },
-                        url: {
-                            type: 'string',
-                            value: value?.previewImg
+        case 'color': {
+            return createDocumentField({
+                fieldValue: value,
+                modelField: modelField,
+                documentFieldBaseProps: { type: 'color' },
+                documentFieldSpecificProps: (value: any) => {
+                    if (!value) {
+                        return undefined;
+                    }
+                    return {
+                        value: _.get(value, 'hex')
+                    };
+                }
+            });
+        }
+        case 'richText': {
+            return createDocumentField({
+                fieldValue: value,
+                modelField: modelField,
+                documentFieldBaseProps: { type: 'richText' },
+                documentFieldSpecificProps: (value: any) => {
+                    if (!value) {
+                        return undefined;
+                    }
+                    return {
+                        value: value,
+                        hint: flattenRichText(value).substring(0, 200)
+                    };
+                }
+            });
+        }
+        case 'image': {
+            if (modelField.source && ['cloudinary', 'aprimo', 'bynder'].includes(modelField.source)) {
+                return createDocumentField({
+                    fieldValue: value,
+                    modelField: modelField,
+                    documentFieldBaseProps: {
+                        type: 'image',
+                        source: modelField.source
+                    },
+                    documentFieldSpecificProps: (value: any) => {
+                        if (!value) {
+                            return undefined;
                         }
+                        return {
+                            sourceData: value,
+                            ...(modelField.source === 'bynder'
+                                ? {
+                                      fields: {
+                                          title: {
+                                              type: 'string',
+                                              value: value?.name
+                                          },
+                                          url: {
+                                              type: 'string',
+                                              value: value?.previewImg
+                                          }
+                                      }
+                                  }
+                                : null)
+                        };
                     }
-                };
-            }
-            return {
-                type: 'reference',
-                refId: _.get(value, 'asset._ref'),
-                refType: 'asset'
-            };
-        case 'file':
-            if (!value) {
-                return null;
-            }
-            return {
-                type: 'reference',
-                refId: _.get(value, 'asset._ref'),
-                refType: 'asset'
-            };
-        case 'slug':
-            if (!value) {
-                return null;
+                });
             }
-            return {
-                type: 'slug',
-                value: _.get(value, 'current')
-            };
+            return createDocumentField({
+                fieldValue: value,
+                // The modelField.type and documentField.type should match.
+                // However, in the case of the modelField.type === 'image',
+                // it is OK to have the documentField.type === 'reference'
+                // and documentField.type === 'asset.
+                modelField: modelField as unknown as StackbitTypes.FieldReference,
+                documentFieldBaseProps: {
+                    type: 'reference',
+                    refType: 'asset'
+                },
+                documentFieldSpecificProps: (value: any) => {
+                    if (!value) {
+                        return undefined;
+                    }
+                    return {
+                        refId: _.get(value, 'asset._ref')
+                    };
+                }
+            });
+        }
+        case 'file': {
+            return createDocumentField({
+                fieldValue: value,
+                // The modelField.type and documentField.type should match.
+                // However, in the case of the modelField.type === 'file',
+                // it is OK to have the documentField.type === 'reference'
+                // and documentField.type === 'asset.
+                modelField: modelField as unknown as StackbitTypes.FieldReference,
+                documentFieldBaseProps: {
+                    type: 'reference',
+                    refType: 'asset'
+                },
+                documentFieldSpecificProps: (value: any) => {
+                    if (!value) {
+                        return undefined;
+                    }
+                    return {
+                        refId: _.get(value, 'asset._ref')
+                    };
+                }
+            });
+        }
+        case 'slug': {
+            return createDocumentField({
+                fieldValue: value,
+                modelField: modelField,
+                documentFieldBaseProps: { type: 'slug' },
+                documentFieldSpecificProps: (value: any) => {
+                    if (!value) {
+                        return undefined;
+                    }
+                    return {
+                        value: _.get(value, 'current')
+                    };
+                }
+            });
+        }
         default: {
             const _exhaustiveCheck: never = modelField;
             return _exhaustiveCheck;
@@ -408,7 +535,7 @@ type CommonFieldsType = {
 };
 
 function commonFields({ draftDocument, publishedDocument, documentHistory }: CommonFieldsType): {
-    status: ContentSourceTypes.Document['status'];
+    status: StackbitTypes.Document['status'];
     createdAt: string;
     updatedAt: string;
     updatedBy: string[];
@@ -420,7 +547,7 @@ function commonFields({ draftDocument, publishedDocument, documentHistory }: Com
     }
 
     const isDraft = isDraftId(document._id);
-    let status: ContentSourceTypes.Document['status'];
+    let status: StackbitTypes.Document['status'];
     if (isDraft && !publishedDocument) {
         status = 'added';
     } else {
@@ -437,82 +564,56 @@ function commonFields({ draftDocument, publishedDocument, documentHistory }: Com
     };
 }
 
-interface FieldListMultiItem {
-    type: 'list';
-    items: ContentSourceTypes.FieldListItems[];
-}
-
-/**
- * Sanity 'Array' field type can hold multiple field types.
- *
- * For example, Sanity Arrays can simultaneously include items of `model`
- * and `reference` types. https://www.sanity.io/docs/array-type#wT47gyCx
- *
- * With that, Sanity Arrays cannot include both primitive and complex types:
- * https://www.sanity.io/docs/array-type#fNBIr84P
- *
- * TODO:
- * This is not yet supported by Stackbit's TypeScript types, so the `any`
- * must be used. Additionally, if a Sanity array has multiple types of items one
- * of which is the 'object' type, then it will also have the 'name' property to
- * allow matching 'object' items to their types. The 'name' property is not
- * supported in Stackbit list items, so '@ts-ignore' is used.
- *
- * However, Stackbit client app should be able to render this types of lists correctly.
- *
- * @example A list that can include items of type 'model', 'reference' and 'object'.
- * {
- *     type: 'list',
- *     items: [{
- *         type: 'model',
- *         models: [...]
- *     }, {
- *         type: 'reference',
- *         models: [...]
- *     }, {
- *         type: 'object',
- *         name: 'nested_object_name',
- *         fields: {...}
- *     }]
- * }
- */
-function getItemTypeForListItem(listItem: any, fieldModel: FieldListMultiItem): ContentSourceTypes.FieldListItems | null {
-    // Handle primitive list item types
-    // For primitive list items, the list will hold the primitive values as is,
-    // therefore, use JavaScript's `typeof` to infer the type of the values
-    const type = _.get(listItem, '_type');
-    if (!type) {
-        const type = typeof listItem;
-        if (typeIsPrimitive(type)) {
-            return { type: type } as ContentSourceTypes.FieldListItems;
+function createDocumentField<
+    Type extends StackbitTypes.FieldType,
+    BaseProps extends StackbitTypes.DocumentFieldBasePropsForType<Type>,
+    SpecificProps extends StackbitTypes.DocumentFieldSpecificPropsForType<Type>
+>({
+    fieldValue,
+    modelField,
+    documentFieldBaseProps,
+    documentFieldSpecificProps
+}: {
+    fieldValue: any;
+    modelField: StackbitTypes.FieldForType<Type> | StackbitTypes.FieldListItemsForType<Type>;
+    documentFieldBaseProps: BaseProps;
+    documentFieldSpecificProps: (value: any) => SpecificProps | undefined;
+}): (BaseProps & (SpecificProps | { localized: true; locales: Record<string, { locale: string } & SpecificProps> })) | undefined {
+    if (isLocalizedModelField(modelField)) {
+        if (!Array.isArray(fieldValue)) {
+            return undefined;
         }
-        return null;
+        return {
+            ...documentFieldBaseProps,
+            localized: true,
+            locales: _.reduce(
+                fieldValue,
+                (accum: Record<string, { locale: string } & SpecificProps>, localizedItem: { _key: string; value: any }) => {
+                    if (localizedItem === null || typeof localizedItem === 'undefined') {
+                        return accum;
+                    }
+                    const fieldSpecificProps = documentFieldSpecificProps(localizedItem.value);
+                    if (!fieldSpecificProps) {
+                        return accum;
+                    }
+                    accum[localizedItem._key] = {
+                        locale: localizedItem._key,
+                        ...fieldSpecificProps
+                    };
+                    return accum;
+                },
+                {}
+            )
+        };
     }
-    const itemModels = fieldModel.items;
-    if (type === 'reference') {
-        return _.find(itemModels, { type: 'reference' }) ?? null;
-    } else if (type === 'block') {
-        return _.find(itemModels, { type: 'richText' }) ?? null;
-    } else {
-        return (
-            _.find(itemModels, (itemModel) => {
-                if (itemModel.type === 'model') {
-                    return _.includes(itemModel.models, type);
-                } else {
-                    // if field was one of base types (object, image, slug, etc.)
-                    // and it had a "name" property, then the "_type" will be equal to that name,
-                    // otherwise the "_type" will be equal to the base type
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    // @ts-ignore
-                    return itemModel.name === type || itemModel.type === type;
-                }
-            }) ?? null
-        );
+    const fieldSpecificProps = documentFieldSpecificProps(fieldValue);
+    if (!fieldSpecificProps) {
+        return undefined;
     }
-}
-
-function typeIsPrimitive(type: string): type is 'string' | 'number' | 'boolean' {
-    return ['string', 'number', 'boolean'].includes(type);
+    return {
+        ...documentFieldBaseProps,
+        ...fieldSpecificProps
+    };
 }
 
 function flattenRichText(richTextArray: any) {
@@ -541,7 +642,7 @@ function flattenRichText(richTextArray: any) {
     );
 }
 
-function getScheduledActionState(sanitySchedule: SanitySchedule): ScheduledActionState {
+function getScheduledActionState(sanitySchedule: SanitySchedule): StackbitTypes.ScheduledActionState {
     if (sanitySchedule.state === 'cancelled' && sanitySchedule.stateReason !== 'cancelled by user') {
         return 'failed';
     }