@stackbit/cms-core 0.0.3

package/src/encoder.js

@@ -0,0 +1,315 @@
+const _ = require('lodash');
+const consts = require('./consts');
+const { mergeAtPath, omitByNil } = require('./utils');
+
+function mapObjectFields({ data, model, fieldDataPath, fieldDataPathsInverted, fieldModelPath, encodeValue, delegate }) {
+    if (!fieldModelPath) {
+        fieldModelPath = [model.name];
+    }
+
+    const isRoot = fieldDataPath.length === 1;
+    const metadata = delegate.getItemMetadata(data, model, isRoot);
+    const fields = delegate.getItemFields(data, model);
+
+    return _.reduce(
+        fields,
+        (accum, field) => {
+            const fieldModel = _.find(model.fields, { name: field.name });
+
+            // if field model wasn't found ignore this field
+            if (!fieldModel) {
+                return accum;
+            }
+
+            // don't include const fields
+            if (_.has(fieldModel, 'const')) {
+                return accum;
+            }
+
+            let childFieldModelPath;
+            if (_.get(model, 'isList') && field.name === 'items') {
+                childFieldModelPath = fieldModelPath;
+            } else {
+                childFieldModelPath = _.concat(fieldModelPath, field.name);
+            }
+
+            const fieldPath = ['fields', field.name];
+
+            const mapLocalizedField = (accum, localizedField) => {
+                const localePath = fieldModel.localized ? ['locales', localizedField.locale] : [];
+                const fullFieldDataPath = _.concat(fieldPath, localePath);
+
+                const mappedData = mapField({
+                    fieldValue: localizedField.value,
+                    fieldModel: fieldModel,
+                    fieldDataPath: _.concat(fieldDataPath, fullFieldDataPath),
+                    fieldDataPaths: accum.fieldDataPaths,
+                    fieldDataPathsInverted: fieldDataPathsInverted,
+                    fieldModelPath: childFieldModelPath,
+                    delegate: delegate
+                });
+                if (localizedField.locale && localizedField.locale !== '_unset') {
+                    mappedData.fieldData.locale = localizedField.locale;
+                }
+                return {
+                    fieldData: mergeAtPath(accum.fieldData, fullFieldDataPath, omitByNil(mappedData.fieldData))
+                };
+            };
+
+            // always create 'fields' as object, even for objects that have field names as numbers
+            _.setWith(accum.fieldData, fieldPath, fieldModelToFieldData(fieldModel), Object);
+
+            if (fieldModel.localized) {
+                accum = mapLocalizedField(accum, { locale: '_unset' });
+            }
+
+            if (_.has(field, 'locales')) {
+                return _.reduce(
+                    field.locales,
+                    (accum, localizedField) => {
+                        return mapLocalizedField(accum, localizedField);
+                    },
+                    accum
+                );
+            }
+
+            return mapLocalizedField(accum, field);
+        },
+        {
+            fieldData: metadata
+        }
+    );
+}
+
+function mapField({ fieldValue, fieldModel, fieldDataPath, fieldModelPath, delegate }) {
+    if (_.includes(consts.SIMPLE_VALUE_FIELDS, fieldModel.type)) {
+        return {
+            fieldData: { value: fieldValue }
+        };
+    } else if (['enum', 'style'].includes(fieldModel.type)) {
+        return {
+            fieldData: { value: fieldValue }
+        };
+    } else if (fieldModel.type === 'list') {
+        const itemsModel = _.get(fieldModel, 'items');
+        let getListItemModel;
+        if (_.isArray(itemsModel)) {
+            // in Sanity, list items may have multiple types, in this case, 'items' will be an array
+            getListItemModel = (listItem, fieldModel) => delegate.getItemTypeForListItem(listItem, fieldModel);
+        } else {
+            // get the type of list items, if type is not defined, set string as it is the default
+            const listItemsType = _.get(itemsModel, 'type', 'string');
+            getListItemModel = _.constant(_.defaults({}, itemsModel, { type: listItemsType }));
+        }
+        return _.reduce(
+            fieldValue,
+            (accum, listItem, listIdx) => {
+                const itemModel = getListItemModel(listItem, fieldModel);
+                let mappedData;
+                if (!itemModel) {
+                    mappedData = unresolvedModel();
+                    accum.fieldData.items = _.concat(accum.fieldData.items, mappedData.fieldData);
+                } else {
+                    mappedData = mapField({
+                        fieldValue: listItem,
+                        fieldModel: itemModel,
+                        fieldDataPath: _.concat(fieldDataPath, ['items', listIdx]),
+                        fieldModelPath: fieldModelPath,
+                        delegate
+                    });
+                    accum.fieldData.items = _.concat(accum.fieldData.items, fieldModelToFieldData(itemModel, mappedData.fieldData));
+                }
+                return {
+                    fieldData: accum.fieldData
+                };
+            },
+            {
+                fieldData: { items: [] }
+            }
+        );
+    } else if (fieldModel.type === 'object') {
+        // inline object
+        if (!fieldValue) {
+            return unsetObject();
+        }
+        return mapObjectFields({
+            data: fieldValue,
+            model: fieldModel,
+            fieldDataPath,
+            fieldModelPath,
+            delegate
+        });
+    } else if (fieldModel.type === 'reference') {
+        if (!fieldValue) {
+            return unsetObject();
+        }
+        const isLink = delegate.isLinkItem(fieldValue);
+        if (isLink) {
+            return unresolvedReference(fieldValue, delegate);
+        }
+        const model = delegate.getModelForItemOfReferenceType(fieldValue);
+        if (!model) {
+            return unresolvedModel();
+        }
+        return mapObjectFields({
+            data: fieldValue,
+            model,
+            fieldDataPath,
+            delegate
+        });
+    } else if (fieldModel.type === 'model') {
+        if (!fieldValue) {
+            return unsetObject();
+        }
+        const fieldModels = _.get(fieldModel, 'models', []);
+        const modelsByName = delegate.getModelsByName();
+        const model = fieldModels.length === 1 ? _.get(modelsByName, fieldModels[0]) : delegate.getModelForItemOfModelsType(fieldValue);
+        if (!model) {
+            return unresolvedModel();
+        }
+        return mapObjectFields({
+            data: fieldValue,
+            model,
+            fieldDataPath,
+            delegate
+        });
+    } else {
+        // for everything else, delegate encoding to the delegate
+        const fieldData = {};
+        const encodedField = delegate.encodeField(fieldValue, fieldModel, fieldDataPath);
+        if (encodedField) {
+            if (_.has(encodedField, 'fieldData')) {
+                _.assign(fieldData, encodedField.fieldData);
+            }
+        }
+        return {
+            fieldData: omitByNil(fieldData)
+        };
+    }
+}
+
+function fieldModelToFieldData(fieldModel, overrides) {
+    const type = ['reference', 'model'].includes(fieldModel.type) ? 'object' : fieldModel.type;
+    return omitByNil(
+        _.assign(
+            {
+                type: type,
+                label: fieldModel.label,
+                description: fieldModel.description,
+                // fieldType: fieldModel.type,
+                // fieldLabel: fieldModel.label,
+
+                // "localized" field will be excluded from final fieldData by decoder
+                localized: fieldModel.localized,
+
+                // "models" field will be excluded from final fieldData by decoder
+                models: getFieldModelNames(fieldModel)
+            },
+
+            fieldModel.type === 'markdown'
+                ? {
+                      multiElement: true
+                  }
+                : null,
+
+            fieldModel.type === 'enum'
+                ? {
+                      options: _.get(fieldModel, 'options', []),
+                      source: _.get(fieldModel, 'source')
+                  }
+                : null,
+
+            overrides
+        )
+    );
+}
+
+function getFieldModelNames(fieldModel) {
+    const fieldType = fieldModel.type;
+    if (fieldType === 'reference' || fieldType === 'model') {
+        return _.clone(_.get(fieldModel, 'models', []));
+    } else if (fieldModel.type === 'list') {
+        const itemsModel = _.get(fieldModel, 'items');
+        // in Sanity, array can have items of multiple types
+        if (_.isArray(itemsModel)) {
+            return Array.from(
+                _.reduce(
+                    itemsModel,
+                    (accum, itemModel) => {
+                        return new Set([...accum, ...(getFieldModelNames(itemModel) || [])]);
+                    },
+                    new Set()
+                )
+            );
+        } else {
+            return getFieldModelNames(itemsModel);
+        }
+    }
+    return null;
+}
+
+function unsetObject() {
+    return {
+        fieldData: {
+            isUnset: true
+        }
+    };
+}
+
+function unresolvedReference(fieldValue, delegate) {
+    return {
+        fieldData: {
+            type: 'unresolved_reference',
+            refId: delegate.getReferenceId(fieldValue),
+            refType: 'object'
+        }
+    };
+}
+
+function unresolvedModel() {
+    return {
+        fieldData: {
+            type: 'unresolved_model'
+        }
+    };
+}
+
+function mapData(data, prevEncodingResult, delegate) {
+    // scan model instances and replace their 'data' with an identity-mapped data
+    return _.reduce(
+        data,
+        (accum, item) => {
+            const model = delegate.getModelForRootItem(item);
+            if (!model) {
+                return {
+                    fieldData: accum.fieldData
+                };
+            }
+            const itemId = delegate.getItemId(item);
+            // todo: pass the accumulated hashedData to all children, because we need to remove duplicate fieldPaths from it per strategy when a field has changed (because we might get partial field data)
+            // todo: create inverse map to find duplications
+            const mappedData = mapObjectFields({
+                data: item,
+                model: model,
+                fieldDataPath: [itemId],
+                delegate: delegate
+            });
+            return {
+                fieldData: _.assign(accum.fieldData, { [itemId]: mappedData.fieldData })
+            };
+        },
+        {
+            fieldData: _.get(prevEncodingResult, 'fieldData', {})
+        }
+    );
+}
+
+function encodeData({ data, prevEncodingResult, delegate }) {
+    data = _.cloneDeep(data);
+    const mappedData = mapData(data, prevEncodingResult, delegate);
+    return {
+        fieldData: mappedData.fieldData
+    };
+}
+
+module.exports = encodeData;

package/src/index.js

@@ -0,0 +1,13 @@
+const encodeData = require('./encoder');
+const stackbit = require('./stackbit');
+const annotator = require('./annotator');
+const utils = require('./utils');
+const consts = require('./consts');
+
+module.exports = {
+    utils,
+    consts,
+    annotator,
+    encodeData,
+    stackbit
+};

package/src/stackbit/index.js

@@ -0,0 +1,55 @@
+const _ = require('lodash');
+const { loadConfig, isListDataModel } = require('@stackbit/sdk');
+
+module.exports = {
+    fetchAndConvertSchema
+};
+
+function fetchAndConvertSchema(options) {
+    return loadConfig({ dirPath: options.dirPath }).then(({ config, errors }) => {
+        if (!config) {
+            return { schema: {}, errors };
+        }
+        wrapListDataModels(config);
+        const schema = _.pick(config, [
+            'stackbitVersion',
+            'ssgName',
+            'ssgVersion',
+            'nodeVersion',
+            'devCommand',
+            'cmsName',
+            'import',
+            'publishDir',
+            'staticDir',
+            'uploadDir',
+            'assets',
+            'dataDir',
+            'pagesDir',
+            'pageLayoutKey',
+            'objectTypeKey',
+            'excludePages',
+            'logicFields',
+            'contentModels',
+            'modelsSource',
+            'models',
+            'presets'
+        ]);
+        return { schema, errors };
+    });
+}
+
+function wrapListDataModels(config) {
+    _.forEach(config.models, (model) => {
+        if (!isListDataModel(model)) {
+            return;
+        }
+        _.set(model, 'fields', [
+            {
+                type: 'list',
+                name: 'items',
+                items: model.items
+            }
+        ]);
+        _.unset(model, 'items');
+    });
+}