@stackbit/cms-core 0.1.21 → 0.1.22-alpha.0

package/src/utils/schema-utils.js

@@ -1,212 +0,0 @@
-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';
-}