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

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,

package/src/utils/schema-utils.js

@@ -0,0 +1,212 @@
+const _ = require('lodash');
+
+const FIELD_TYPES = [
+    'string',
+    'text',
+    'markdown',
+    'html',
+    'url',
+    'slug',
+    'number',
+    'boolean',
+    'select',
+    'enum',
+    'date',
+    'datetime',
+    'color',
+    'image',
+    'file',
+    'json',
+    'reference',
+    'model',
+    'models',
+    'object',
+    'list',
+    'array'
+];
+
+module.exports = {
+    FIELD_TYPES,
+    isObjectField,
+    isModelField,
+    isModelsField,
+    isReferenceField,
+    isCustomModelField,
+    isListField,
+    isListOfObjectsField,
+    isListOfModelField,
+    isListOfModelsField,
+    isListOfCustomModelField,
+    isListOfReferenceField,
+    getListItemsField,
+    iterateModelFieldsRecursively,
+    resolveLabelFieldForModel,
+    resolveLabelFieldFromFields,
+    getUrlPath,
+    getNormalizedModelType
+};
+
+
+function resolveLabelFieldForModel(model, modelLabelFieldPath, fields) {
+    let labelField = _.get(model, modelLabelFieldPath, null);
+    if (labelField) {
+        return labelField;
+    }
+    return resolveLabelFieldFromFields(fields);
+}
+
+function resolveLabelFieldFromFields(fields) {
+    let labelField = null;
+    let titleField = _.find(fields, field => field.name === 'title' && _.includes(['string', 'text'], field.type));
+    if (!titleField) {
+        // get first string field
+        titleField = _.find(fields, {type: 'string'});
+    }
+    if (titleField) {
+        labelField = _.get(titleField, 'name');
+    }
+    return labelField;
+}
+
+function isObjectField(field) {
+    return field.type === 'object';
+}
+
+function isReferenceField(field) {
+    return field.type === 'reference';
+}
+
+function isCustomModelField(field, modelsByName) {
+    return !FIELD_TYPES.includes(field.type) && (!modelsByName || _.has(modelsByName, field.type));
+}
+
+function isModelField(field) {
+    return field.type === 'model';
+}
+
+function isModelsField(field) {
+    return field.type === 'models';
+}
+
+function isListField(field) {
+    return ['list', 'array'].includes(field.type);
+}
+
+function isListOfObjectsField(field) {
+    return isListField(field) && isObjectField(getListItemsField(field));
+}
+
+function isListOfModelField(field) {
+    return isListField(field) && isModelField(getListItemsField(field));
+}
+
+function isListOfModelsField(field) {
+    return isListField(field) && isModelsField(getListItemsField(field));
+}
+
+function isListOfCustomModelField(field) {
+    return isListField(field) && isCustomModelField(getListItemsField(field));
+}
+
+function isListOfReferenceField(field) {
+    return isListField(field) && isReferenceField(getListItemsField(field));
+}
+
+/**
+ * Gets a list field and returns its items field. If list field does not define
+ * items field, the default field is string:
+ *
+ * @example
+ * listItemField = getListItemsField({
+ *   type: 'list',
+ *   name: '...',
+ *   items: { type: 'object', fields: [] }
+ * }
+ * listItemField => {
+ *   type: 'object',
+ *   name: '...',
+ *   fields: []
+ * }
+ *
+ * // list field without `items`
+ * listItemField = getListItemsField({ type: 'list', name: '...' }
+ * listItemField => { type: 'string' }
+ *
+ * @param {Object} field
+ * @return {Object}
+ */
+function getListItemsField(field) {
+    // items.type defaults to string
+    return _.defaults({}, _.get(field, 'items', {}), {type: 'string'});
+}
+
+/**
+ * This function invokes the `iterator` function for every field of the `model`.
+ * It recursively traverses through fields of type `object` and `list` with
+ * items of type `object` and invokes the `iterator` on their child fields,
+ * and so on. The traversal is a depth-first and the `iterator` is invoked
+ * before traversing the field's child fields.
+ *
+ * The iterator is invoked with two parameters, `field` and `fieldPath`. The
+ * `field` is the currently iterated field, and `fieldPath` is an array of
+ * strings indicating the path of the `field` relative to the model.
+ *
+ * @example
+ * model = {
+ *   fields: [
+ *     { name: "title", type: "string" },
+ *     {
+ *       name: "banner",
+ *       type: "object",
+ *       fields: [
+ *         { name: "logo", type: "image" }
+ *     ]}
+ *     {
+ *       name: "actions",
+ *       type: "list",
+ *       items: {
+ *         type: "object",
+ *         fields: [
+ *           {name: "label", type: "string"}
+ *         ]
+ *       }
+ *     }
+ *   ]
+ * }
+ * iterateModelFieldsRecursively(model, iterator);
+ * // will call the iterator with following field.name and fieldPath
+ * - 'title', ['fields', 'title']
+ * - 'banner', ['fields', 'banner']
+ * - 'logo', ['fields', 'banner', 'fields', 'logo']
+ * - 'actions', ['fields', 'actions']
+ * - 'label', ['fields', 'actions', 'items', 'fields', 'label']
+ *
+ * @param {Object} model The root model to iterate fields
+ * @param {Function} iterator The iterator function
+ * @param {Array} [fieldPath]
+ */
+function iterateModelFieldsRecursively(model, iterator, fieldPath = []) {
+    const fields = _.get(model, 'fields', []);
+    fieldPath = fieldPath.concat('fields');
+    _.forEach(fields, (field) => {
+        const childFieldPath = fieldPath.concat(field.name);
+        iterator(field, childFieldPath);
+        if (isObjectField(field)) {
+            iterateModelFieldsRecursively(field, iterator, childFieldPath);
+        } else if (isListOfObjectsField(field)) {
+            iterateModelFieldsRecursively(getListItemsField(field), iterator, childFieldPath.concat('items'));
+        }
+    });
+}
+
+function getUrlPath(stackbitModel) {
+    const modelType = getNormalizedModelType(stackbitModel);
+    if (modelType === 'page') {
+        return _.get(stackbitModel, 'urlPath', '/{slug}');
+    }
+    return null;
+}
+
+function getNormalizedModelType(stackbitModel) {
+    return stackbitModel ? (stackbitModel.type === 'config' ? 'data' : stackbitModel.type) : 'object';
+}

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

@@ -144,7 +144,7 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                       }),
                 ...localeFields(docField.localized)
             };
-        case 'reference': {
+        case 'reference':
             if (docField.localized) {
                 const { type, refType, localized, locales, ...base } = docField;
                 const localeProps = locales && locale ? locales[locale] : undefined;
@@ -179,43 +179,6 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                 ...base,
                 ...localeFields(docField.localized)
             };
-        }
-        case 'cross-reference': {
-            if (docField.localized) {
-                const { type, refType, localized, locales, ...base } = docField;
-                const localeProps = locales && locale ? locales[locale] : undefined;
-                // if reference field isUnset === true, it behaves like a regular object
-                if (!localeProps) {
-                    return {
-                        type: 'object',
-                        isUnset: true,
-                        ...base,
-                        ...localeFields(localized)
-                    };
-                }
-                return {
-                    type: 'cross-reference',
-                    refType: refType,
-                    ...base,
-                    ...localeProps,
-                    ...localeFields(localized)
-                };
-            }
-            const { type, refType, ...base } = docField;
-            if (base.isUnset) {
-                return {
-                    type: 'object',
-                    ...base,
-                    ...localeFields(docField.localized)
-                };
-            }
-            return {
-                type: 'cross-reference',
-                refType: refType,
-                ...base,
-                ...localeFields(docField.localized)
-            };
-        }
         case 'list':
             if (docField.localized) {
                 const { localized, locales, ...base } = docField;

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

@@ -179,36 +179,6 @@ function mapStoreFieldToCSIField(documentField: ContentStoreTypes.DocumentField)
                 refId: documentField.refId
             };
         }
-        case 'cross-reference': {
-            if (documentField.localized) {
-                if (_.isEmpty(documentField.locales)) {
-                    return;
-                }
-                return {
-                    type: 'json',
-                    localized: true,
-                    locales: _.mapValues(documentField.locales, (locale) => ({
-                        locale: locale.locale,
-                        value: {
-                            refId: locale.refId,
-                            refSrcType: locale.refSrcType,
-                            srcProjectId: locale.refProjectId
-                        }
-                    }))
-                };
-            }
-            if (documentField.isUnset) {
-                return;
-            }
-            return {
-                type: 'json',
-                value: {
-                    refId: documentField.refId,
-                    refSrcType: documentField.refSrcType,
-                    srcProjectId: documentField.refProjectId
-                }
-            };
-        }
         case 'list': {
             if (documentField.localized) {
                 if (_.isEmpty(documentField.locales)) {