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

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)) {