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

package/src/sanity-schema-converter.ts

@@ -1,54 +1,276 @@
 import _ from 'lodash';
-import { Field, FieldGroupItem, Model } from '@stackbit/types';
-import * as ContentSourceTypes from '@stackbit/types';
-import { deepMap, omitByNil } from '@stackbit/utils';
+import * as StackbitTypes from '@stackbit/types';
+import type * as SanityTypes from '@sanity/types';
+import { deepMap, omitByNil, omitByUndefined } from '@stackbit/utils';
 import { resolveLabelFieldForModel } from './utils';
 
-// sanity cloudinary plugin adds these models, we are replacing them to our internal image model, so we removing them from schema response
+// Sanity's cloudinary and other 3rd party DRM plugins add the following models.
+// These models are removed when converting the schema and the fields referencing
+// these models are replaced with our regular "image" field with a "source" property
+// matching to the name of the supported DRM.
 const thirdPartyImageModels = ['cloudinary.asset', 'cloudinary.assetDerived', 'bynder.asset', 'aprimo.asset', 'aprimo.cdnasset'];
-const skipModels = [...thirdPartyImageModels, 'media.tag'];
+const skipModels = [...thirdPartyImageModels, 'media.tag', 'slug', 'markdown', 'json', 'color', 'hslaColor', 'hsvaColor', 'rgbaColor'];
+const internationalizedArrayPrefix = 'internationalizedArray';
 
-export function convertSchema(schema: any): { models: Model[] } {
-    // sanity schema allow arrays to be at the root level, we don't.
-    // map all root arrays, then pass them to rest of the model and reference them as if they were inline
-    // hope there is no cyclic references from array objects from within array objects
-    const filteredModels = schema.models.filter((model: any) => !model.name.startsWith('sanity.') && !skipModels.includes(model.name));
-    const [arrayModels, nonArrayModels] = _.partition(filteredModels, { type: 'array' });
-    const arrayModelsByName = _.keyBy(arrayModels, 'name');
-    const models = nonArrayModels.map((model) => {
-        return mapObjectModel(model, arrayModelsByName);
+export type SchemaContext = null;
+
+export type ModelWithContext = StackbitTypes.Model<ModelContext>;
+export type ModelContext = {
+    localizedFieldsModelMap?: LocalizedFieldsModelMap;
+    fieldAliasMap?: FieldAliasMap;
+} | null;
+
+/**
+ * Maps model fields to the Internationalized Array types
+ * The key is the field path of the field within the model.
+ */
+export type LocalizedFieldsModelMap = Record<
+    string,
+    {
+        arrayModelName: string;
+        arrayValueModelName: string;
+    }
+>;
+
+export type FieldAliasMap = Record<
+    string,
+    {
+        origTypeName: string;
+        resolvedTypeName: string;
+    }[]
+>;
+
+/**
+ * Converts Sanity schema to Netlify Create Schema.
+ *
+ * @param schema Schema as received from sanity-schema-converter.js
+ * @param defaultLocale The default locale specified in the SanityContentSource constructor.
+ */
+export function convertSchema({
+    schema,
+    logger,
+    defaultLocale
+}: {
+    schema: { models: SanityTypes.SchemaTypeDefinition[] };
+    logger: StackbitTypes.Logger;
+    defaultLocale?: string;
+}): {
+    models: ModelWithContext[];
+    locales: StackbitTypes.Locale[];
+} {
+    // First, skip all Sanity internal models with names starting with "sanity."
+    // and models defined in skipModels.
+    const filteredModels = schema.models.filter((model) => {
+        return !model.name.startsWith('sanity.') && !skipModels.includes(model.name);
+    });
+
+    // Split models into three groups:
+    // 1. Regular "document" and "objets" models that map to Netlify Create's
+    //    "data" and "object" models respectively.
+    // 2. Models with names starting with "internationalizedArray...". These are
+    //    special models produced by Sanity's internationalized-array plugin
+    //    https://www.sanity.io/plugins/internationalized-array
+    // 3. Type alias models, which are aliases to regular fields like "array",
+    //    "string", etc.
+    const {
+        i18nModels = [],
+        documentAndObjectModels = [],
+        typeAliasModels = []
+    } = _.groupBy(filteredModels, (model) => {
+        if (model.name.startsWith(internationalizedArrayPrefix)) {
+            return 'i18nModels';
+        } else if (['document', 'object'].includes(model.type)) {
+            return 'documentAndObjectModels';
+        } else {
+            return 'typeAliasModels';
+        }
+    }) as unknown as {
+        i18nModels: SanityTypes.TypeAliasDefinition<string, SanityTypes.IntrinsicTypeName | undefined>[];
+        documentAndObjectModels: (SanityTypes.DocumentDefinition | SanityTypes.ObjectDefinition)[];
+        typeAliasModels: SanityTypes.TypeAliasDefinition<string, SanityTypes.IntrinsicTypeName | undefined>[];
+    };
+
+    // Get all locale codes from Internationalized Array models
+    const locales = getLocalesFromInternationalizedArrays(i18nModels, defaultLocale);
+    // Create map of Internationalized Array
+    const { i18nArrayModelMap, i18nValueModelMap } = getLocalizedModelMap(i18nModels);
+
+    const typeAliasMap = _.keyBy(typeAliasModels, 'name');
+
+    const models = documentAndObjectModels.map((model): StackbitTypes.DataModel<ModelContext> | StackbitTypes.ObjectModel<ModelContext> => {
+        const localizedFieldsModelMap = {};
+        const fieldAliasMap = {};
+        try {
+            const stackbitModel = mapObjectModel({
+                model,
+                modelFieldPath: [],
+                typeAliasMap,
+                i18nArrayModelMap,
+                localizedFieldsModelMap,
+                fieldAliasMap,
+                seenAliases: []
+            });
+            let context: ModelContext = null;
+            if (!_.isEmpty(localizedFieldsModelMap) || !_.isEmpty(fieldAliasMap)) {
+                context = {
+                    ...(_.isEmpty(localizedFieldsModelMap) ? null : { localizedFieldsModelMap }),
+                    ...(_.isEmpty(fieldAliasMap) ? null : { fieldAliasMap })
+                };
+            }
+            return {
+                ...stackbitModel,
+                context
+            };
+        } catch (error: any) {
+            logger.error(`Error converting model '${model.name}'. ${error.message}`);
+            throw error;
+        }
     });
-    return { models };
+    return {
+        models,
+        locales
+    };
 }
 
-function mapObjectModel(model: any, arrayModelsByName: ContentSourceTypes.ModelMap): Model {
-    // model name can be null for nested objects
+type CommonProps = {
+    modelFieldPath: string[];
+    typeAliasMap: Record<string, any>;
+    i18nArrayModelMap: Record<string, any>;
+    localizedFieldsModelMap: LocalizedFieldsModelMap;
+    fieldAliasMap: FieldAliasMap;
+    seenAliases: string[];
+};
+type SanityObjectFieldOrArrayItem = SanityIntrinsicFieldOrArrayItem<'object'>;
+type MapObjectModelOptions<Type extends SanityTypes.DocumentDefinition | SanityTypes.ObjectDefinition | SanityObjectFieldOrArrayItem> = {
+    model: Type;
+} & CommonProps;
+function mapObjectModel(
+    options: MapObjectModelOptions<SanityTypes.DocumentDefinition | SanityTypes.ObjectDefinition>
+): StackbitTypes.DataModel | StackbitTypes.ObjectModel;
+function mapObjectModel(options: MapObjectModelOptions<SanityObjectFieldOrArrayItem>): StackbitTypes.FieldObject;
+function mapObjectModel({
+    model,
+    ...rest
+}: MapObjectModelOptions<SanityTypes.DocumentDefinition | SanityTypes.ObjectDefinition | SanityObjectFieldOrArrayItem>):
+    | StackbitTypes.DataModel
+    | StackbitTypes.ObjectModel
+    | StackbitTypes.FieldObject {
     const modelName = _.get(model, 'name', null);
     const modelLabel = _.get(model, 'title', modelName ? _.startCase(modelName) : null);
-    const sanityFieldGroups: FieldGroupItem[] = _.get(model, 'groups', []).map((group: any) => ({ name: group.name, label: group.title }));
+    const sanityFieldGroups: StackbitTypes.FieldGroupItem[] = _.get(model, 'groups', []).map((group: any) => ({ name: group.name, label: group.title }));
     const fields = _.get(model, 'fields', []);
-    const mappedFields = mapObjectFields(fields, arrayModelsByName);
+    const mappedFields = mapObjectFields({
+        fields,
+        ...rest
+    });
 
     return omitByNil({
+        // TODO: ensure type aliases work for documents
         type: getNormalizedModelType(model),
         name: modelName,
         label: modelLabel,
         labelField: resolveLabelFieldForModel(model, 'preview.select.title', mappedFields),
         fieldGroups: sanityFieldGroups,
         fields: mappedFields
-    }) as Model;
+    }) as StackbitTypes.DataModel | StackbitTypes.ObjectModel | StackbitTypes.FieldObject;
 }
 
-function mapObjectFields(fields: any[], arrayModelsByName: ContentSourceTypes.ModelMap): Field[] {
+function mapObjectFields({ fields, modelFieldPath, ...rest }: { fields: SanityTypes.FieldDefinition[] } & CommonProps): StackbitTypes.Field[] {
     return _.map(fields, (field) => {
-        return mapField(field, arrayModelsByName);
+        return mapField({
+            field,
+            modelFieldPath: modelFieldPath.concat(field.name),
+            ...rest
+        });
     });
 }
 
-function mapField(field: any, arrayModelsByName: ContentSourceTypes.ModelMap): Field {
-    const type = _.get(field, 'type');
+/**
+ * Maps Sanity FieldDefinition or ArrayOfType to the {@link StackbitTypes.Field}
+ * or the {@link StackbitTypes.FieldListItems} respectively.
+ *
+ * The `mapField()` can be called for object fields or array items.
+ * When called for array items, the 'name' property is optional and the 'hidden'
+ * attribute is not present.
+ */
+function mapField({
+    field,
+    modelFieldPath,
+    typeAliasMap,
+    i18nArrayModelMap,
+    localizedFieldsModelMap,
+    fieldAliasMap,
+    seenAliases
+}: { field: SanityTypes.FieldDefinition | SanityTypes.ArrayOfType } & CommonProps): StackbitTypes.Field {
+    let type = _.get(field, 'type');
     const name = _.get(field, 'name');
     const label = _.get(field, 'title', name ? _.startCase(name) : undefined);
+    const modelFieldPathStr = modelFieldPath.join('.');
+
+    let localized: true | undefined;
+    // TODO: can the Internationalized Array type have an alias?
+    //  e.g.: localizedString an alias to internationalizedArrayString?
+    //  { name: 'localizedString', type: 'internationalizedArrayString' }
+    if (type in i18nArrayModelMap) {
+        // The localization model map can reference a field definition, or a type alias.
+        // i18nArrayModelMap['internationalizedArrayString'] => { valueModelName: 'internationalizedArrayStringValue', valueField: { type: 'string', name: 'value' } }
+        // i18nArrayModelMap['internationalizedArrayBoolean'] => { valueModelName: 'internationalizedArrayBooleanValue', valueField: { type: 'boolean', name: 'value' } }
+        // i18nArrayModelMap['internationalizedArrayInlineReference'] => { valueModelName: 'internationalizedArrayInlineReferenceValue', valueField: { type: 'reference', to: [...], name: 'value' } }
+        // i18nArrayModelMap['internationalizedArrayCustomTypeAlias'] => { valueModelName: 'internationalizedArrayCustomTypeAliasValue', valueField: { type: 'customTypeAlias', name: 'value' } }
+        // etc.
+        if (seenAliases.includes(type)) {
+            throw new Error(`Circular Array aliases are not supported, the Array alias '${type}' is recursively referenced in field '${modelFieldPathStr}'.`);
+        }
+        seenAliases = seenAliases.concat(type);
+        localized = true;
+        field = {
+            ...i18nArrayModelMap[type].valueField,
+            ...field,
+            type: i18nArrayModelMap[type].valueField.type
+        };
+        localizedFieldsModelMap[modelFieldPathStr] = {
+            arrayModelName: type,
+            arrayValueModelName: i18nArrayModelMap[type].valueModelName
+        };
+        type = field.type;
+    }
+
+    const visitedTypes: string[] = [];
+    let addedAlias = false;
+    while (type in typeAliasMap) {
+        if (seenAliases.includes(type)) {
+            throw new Error(`Circular Array aliases not supported, the Array alias ${type} is recursively referenced in field ${modelFieldPathStr}.`);
+        }
+        seenAliases = seenAliases.concat(type);
+        // In Sanity, the properties of the field, override the properties of
+        // the alias. However, the final field type is the type of the alias.
+        if (visitedTypes.includes(type)) {
+            throw new Error(`Circular type alias detected in field ${modelFieldPathStr}: ${visitedTypes.join(' => ')} => ${type}.`);
+        }
+        visitedTypes.push(type);
+        field = {
+            ...typeAliasMap[type],
+            ...field,
+            type: typeAliasMap[type].type
+        };
+        if (!fieldAliasMap[modelFieldPathStr]) {
+            fieldAliasMap[modelFieldPathStr] = [];
+        }
+        const fieldAliases = fieldAliasMap[modelFieldPathStr]!;
+        // Non list fields should have only one alias entry.
+        // List fields, can have multiple aliases per list item type.
+        if (!addedAlias) {
+            addedAlias = true;
+            fieldAliases.push({
+                origTypeName: type,
+                resolvedTypeName: field.type
+            });
+        } else {
+            fieldAliases[fieldAliases.length - 1]!.resolvedTypeName = field.type;
+        }
+        type = field.type;
+    }
+
     const description = _.get(field, 'description');
     const readOnly = _.get(field, 'readOnly');
     const isRequired = _.get(field, 'validation.isRequired');
@@ -75,24 +297,30 @@ function mapField(field: any, arrayModelsByName: ContentSourceTypes.ModelMap): F
         }
     }
 
-    const extra = convertField(field, arrayModelsByName);
+    const extra = convertField({
+        field,
+        modelFieldPath,
+        typeAliasMap,
+        i18nArrayModelMap,
+        localizedFieldsModelMap,
+        fieldAliasMap,
+        seenAliases
+    });
 
     return _.assign(
-        _.omitBy(
-            {
-                type: null,
-                name: name,
-                label: label,
-                description: description,
-                group: group,
-                required: isRequired || undefined,
-                default: defaultValue,
-                const: constValue,
-                readOnly: readOnly,
-                hidden: hidden
-            },
-            _.isUndefined
-        ),
+        omitByUndefined({
+            type: null,
+            name: name,
+            label: label,
+            description: description,
+            group: group,
+            required: isRequired || undefined,
+            default: defaultValue,
+            const: constValue,
+            readOnly: readOnly,
+            hidden: hidden,
+            localized: localized
+        }),
         extra
     );
 }
@@ -127,12 +355,12 @@ function convertDefaultValue(defaultValue: any) {
     );
 }
 
-function convertField(field: any, arrayModelsByName: ContentSourceTypes.ModelMap) {
+function convertField({ field, ...rest }: { field: SanityTypes.FieldDefinition | SanityTypes.ArrayOfType } & CommonProps): StackbitTypes.FieldSpecificProps {
     const type = _.get(field, 'type');
     if (!_.has(fieldConverterMap, type)) {
-        return fieldConverterMap.model(field, arrayModelsByName);
+        return fieldConverterMap.model({ field: field as SanityAliasFieldOrArrayItemDefinition<'model'>, ...rest });
     }
-    return _.get(fieldConverterMap, type)(field, arrayModelsByName);
+    return _.get(fieldConverterMap, type)({ field, ...rest });
 }
 
 function getEnumOptions(field: any) {
@@ -149,8 +377,20 @@ function getEnumOptions(field: any) {
     }
 }
 
-const fieldConverterMap = {
-    string: (field: any) => {
+type SanityFieldTypes = Exclude<SanityTypes.IntrinsicTypeName, 'document'>;
+type AliasFieldTypes = 'model' | 'color' | 'markdown' | 'json' | 'cloudinary.asset' | 'bynder.asset' | 'aprimo.cdnasset';
+type SanityIntrinsicFieldOrArrayItem<Type extends SanityFieldTypes> =
+    | (SanityTypes.InlineFieldDefinition[Type] & SanityTypes.FieldDefinitionBase)
+    | SanityTypes.IntrinsicArrayOfDefinition[Type];
+type SanityAliasFieldOrArrayItemDefinition<Type extends string> =
+    | (SanityTypes.TypeAliasDefinition<Type, SanityTypes.IntrinsicTypeName | undefined> & SanityTypes.FieldDefinitionBase)
+    | SanityTypes.ArrayOfEntry<SanityTypes.TypeAliasDefinition<Type, SanityTypes.IntrinsicTypeName | undefined>>;
+const fieldConverterMap: {
+    [Type in SanityFieldTypes]: (options: { field: SanityIntrinsicFieldOrArrayItem<Type> } & CommonProps) => StackbitTypes.FieldSpecificProps;
+} & {
+    [Type in AliasFieldTypes]: (options: { field: SanityAliasFieldOrArrayItemDefinition<Type> } & CommonProps) => StackbitTypes.FieldSpecificProps;
+} = {
+    string: ({ field }) => {
         const options = getEnumOptions(field);
         if (options) {
             return { type: 'enum', options: options };
@@ -167,6 +407,9 @@ const fieldConverterMap = {
     text: () => {
         return { type: 'text' };
     },
+    email: () => {
+        return { type: 'string' };
+    },
     color: () => {
         return { type: 'color' };
     },
@@ -176,21 +419,15 @@ const fieldConverterMap = {
     block: () => {
         return { type: 'richText' };
     },
-    span: () => {
-        // TODO: implement when we will handle parsing of rich text
-    },
-    number: (field: any) => {
+    number: ({ field }) => {
         const validation = _.get(field, 'validation');
         const isInteger = _.get(validation, 'isInteger');
-        return _.omitBy(
-            {
-                type: 'number',
-                subtype: isInteger ? 'int' : 'float',
-                min: _.get(validation, 'min'),
-                max: _.get(validation, 'max')
-            },
-            _.isNil
-        );
+        return omitByNil({
+            type: 'number',
+            subtype: isInteger ? 'int' : 'float',
+            min: _.get(validation, 'min'),
+            max: _.get(validation, 'max')
+        });
     },
     boolean: () => {
         return { type: 'boolean' };
@@ -219,26 +456,43 @@ const fieldConverterMap = {
         return { type: 'image', source: 'aprimo' };
     },
     geopoint: () => {
-        return { type: 'geopoint' };
+        return { type: 'model', models: ['geopoint'] };
     },
-    reference: (field: any) => {
+    reference: ({ field }) => {
         const toItems = _.castArray(_.get(field, 'to', []));
         return {
             type: 'reference',
             models: _.map(toItems, (item) => item.type)
         };
     },
+    crossDatasetReference: ({ field }) => {
+        // TODO: implement cross-reference
+        //  Sanity crossDatasetReference fields can reference between datasets
+        //  of the same project. But Stackbit cross-reference fields cannot
+        //  differentiate environments of the same project as the object in the
+        //  models array only contains the srcType and srcProjectId
+        return {
+            type: 'cross-reference',
+            models: []
+            // models: field.to.map((toItem) => {
+            //     return {
+            //         modelName: toItem.type,
+            //         srcType: 'sanity',
+            //         srcProjectId: '...', // the projectId should be the same as the current one
+            //         // Stackbit cross-references do not have a way to specify different environment
+            //         srcEnvironment: field.dataset
+            //     }
+            // })
+        };
+    },
     json: () => {
         return { type: 'json' };
     },
-    object: (field: any, arrayModelsByName: ContentSourceTypes.ModelMap) => {
-        return mapObjectModel(field, arrayModelsByName);
+    object: ({ field, ...rest }) => {
+        return mapObjectModel({ model: field, ...rest }) as StackbitTypes.FieldObjectProps;
     },
-    model: (field: any, arrayModelsByName: ContentSourceTypes.ModelMap) => {
+    model: ({ field }) => {
         const type = _.get(field, 'type');
-        if (_.has(arrayModelsByName, type)) {
-            return fieldConverterMap.array(arrayModelsByName[type], arrayModelsByName);
-        }
         if (thirdPartyImageModels.includes(type)) {
             const fn = (fieldConverterMap[type as keyof typeof fieldConverterMap] as any) ?? fieldConverterMap.image;
             return fn();
@@ -281,7 +535,7 @@ const fieldConverterMap = {
      *     }]
      * }
      */
-    array: (field: any, arrayModelsByName: ContentSourceTypes.ModelMap) => {
+    array: ({ field, ...rest }) => {
         const options = getEnumOptions(field);
         if (options) {
             return {
@@ -298,13 +552,38 @@ const fieldConverterMap = {
             return { type: 'richText' };
         }
         const items = _.map(ofItems, (item, index) => {
-            return mapField(item, arrayModelsByName);
+            const { modelFieldPath, ...props } = rest;
+            const listModelFieldPath = modelFieldPath.concat('items');
+            const modelFieldPathStr = listModelFieldPath.join('.');
+            // Sanity array fields may consist of anonymous 'object' with names.
+            // When creating such objects, the '_type' should be set to their
+            // name to identify them among other 'object' types.
+            if (item && 'name' in item && item.name && 'type' in item && item.type === 'object') {
+                if (!props.fieldAliasMap[modelFieldPathStr]) {
+                    props.fieldAliasMap[modelFieldPathStr] = [];
+                }
+                props.fieldAliasMap[modelFieldPathStr]!.push({
+                    origTypeName: item.name,
+                    resolvedTypeName: 'object'
+                });
+            }
+            return mapField({
+                field: item,
+                modelFieldPath: listModelFieldPath,
+                ...props
+            });
         });
         let modelNames: string[] = [];
         let referenceModelName: string[] = [];
         const consolidatedItems = [];
         _.forEach(items, (item) => {
             const type = _.get(item, 'type');
+            // If the converted items have only two properties
+            // - type: 'model' and models: [...],
+            // - type: 'reference' and models: [...]
+            // Then, consolidate all their models under the same 'model' or
+            // 'reference' item. Otherwise, if the field has additional properties
+            // like, "name", "label", etc., then add it as a separate items.
             if (type === 'model' && _.has(item, 'models') && _.size(item) === 2) {
                 modelNames = modelNames.concat(_.get(item, 'models'));
             } else if (type === 'reference' && _.has(item, 'models') && _.size(item) === 2) {
@@ -329,12 +608,12 @@ const fieldConverterMap = {
             return {
                 type: 'list',
                 items: _.head(consolidatedItems)
-            };
+            } as StackbitTypes.FieldList;
         }
         return {
             type: 'list',
             items: consolidatedItems
-        };
+        } as unknown as StackbitTypes.FieldList;
     }
 };
 
@@ -342,3 +621,78 @@ function getNormalizedModelType(sanityModel: any) {
     const modelType = _.get(sanityModel, 'type');
     return modelType === 'document' ? 'data' : 'object';
 }
+
+function getLocalesFromInternationalizedArrays(internationalizedArrayModels: any, defaultLocale?: string): StackbitTypes.Locale[] {
+    const localeMap = internationalizedArrayModels
+        .filter((model: any) => model.type === 'array')
+        .reduce((localeMap: Record<string, string>, model: any) => {
+            if (model?.options?.languages && Array.isArray(model?.options?.languages)) {
+                return model?.options?.languages.reduce((localeMap: Record<string, string>, locale: { id: string; title: string }) => {
+                    if (!(locale.id in localeMap)) {
+                        localeMap[locale.id] = locale.title;
+                    }
+                    return localeMap;
+                }, localeMap);
+            }
+            return localeMap;
+        }, {});
+    let defaultLocaleFound = false;
+    const locales = Object.entries(localeMap).map(([localeId, localeTitle]) => {
+        const locale: StackbitTypes.Locale = {
+            code: localeId
+        };
+        if (defaultLocale && localeId === defaultLocale) {
+            defaultLocaleFound = true;
+            locale.default = true;
+        }
+        return locale;
+    });
+    if (!defaultLocaleFound && locales.length > 0) {
+        locales[0]!.default = true;
+    }
+    return locales;
+}
+
+function getLocalizedModelMap(i18nModels: any[]): {
+    i18nArrayModelMap: Record<
+        string,
+        {
+            valueModelName: string;
+            valueField: any;
+        }
+    >;
+    i18nValueModelMap: Record<string, any>;
+} {
+    const [i18nArrayModels, i18nObjectModels] = _.partition(i18nModels, { type: 'array' });
+    const i18nObjectModelsByName = _.keyBy(i18nObjectModels, 'name');
+    return _.reduce(
+        i18nArrayModels,
+        (accum, i18nArrayModel) => {
+            if (Array.isArray(i18nArrayModel.of) && i18nArrayModel.of.length === 1) {
+                const localizedArrayOfItem = i18nArrayModel.of[0];
+                if (localizedArrayOfItem && localizedArrayOfItem.type in i18nObjectModelsByName) {
+                    const valueModelName = localizedArrayOfItem.type;
+                    const localizedArrayValueModel = i18nObjectModelsByName[valueModelName];
+                    const valueField = localizedArrayValueModel.fields[0];
+                    // valueField.name === 'value'
+                    accum.i18nArrayModelMap[i18nArrayModel.name] = {
+                        valueModelName: valueModelName,
+                        valueField: valueField
+                    };
+                    accum.i18nValueModelMap[valueModelName] = valueField;
+                }
+            }
+            return accum;
+        },
+        {
+            i18nArrayModelMap: {} as Record<
+                string,
+                {
+                    valueModelName: string;
+                    valueField: any;
+                }
+            >,
+            i18nValueModelMap: {} as Record<string, any>
+        }
+    );
+}

package/src/sanity-schema-fetcher.ts

@@ -3,7 +3,7 @@ import * as path from 'path';
 import _ from 'lodash';
 import fse from 'fs-extra';
 import { deepMap } from '@stackbit/utils';
-import * as ContentSourceTypes from '@stackbit/types';
+import * as StackbitTypes from '@stackbit/types';
 
 export async function fetchSchemaLegacy({ studioPath }: { studioPath: string }) {
     const getSanitySchema = require('@sanity/core/lib/actions/graphql/getSanitySchema');
@@ -176,8 +176,8 @@ export interface FetchSchemaOptions {
     studioPath: string;
     repoPath: string;
     nodePath?: string;
-    spawnRunner?: ContentSourceTypes.UserCommandSpawner;
-    logger?: ContentSourceTypes.Logger;
+    spawnRunner?: StackbitTypes.UserCommandSpawner;
+    logger?: StackbitTypes.Logger;
 }
 
 export function spawnFetchSchema({ studioPath, nodePath, repoPath, spawnRunner, logger }: FetchSchemaOptions): Promise<any> {