@stackbit/sdk 0.2.22 → 0.2.23

package/src/config/presets-loader.ts

@@ -20,13 +20,14 @@ export async function loadPresets(dirPath: string, config: Config): Promise<Pres
         if (!(await fse.pathExists(presetsDir))) {
             continue;
         }
-        presetFiles.push(
-            ...(await fse.readdir(presetsDir)).filter((fileName) => path.parse(fileName).ext === '.json').map((fileName) => path.join(presetsRelDir, fileName))
-        );
+        const files = (await fse.readdir(presetsDir))
+            .filter((fileName) => ['.json', '.yaml', '.yml'].includes(path.parse(fileName).ext))
+            .map((fileName) => path.join(presetsRelDir, fileName));
+        presetFiles.push(...files);
     }
 
-    const presets: any = {};
-    const presetsByModel: any = {};
+    const presets: Record<string, any> = {};
+    const presetsIdsByModel: Record<string, any> = {};
     const errors: ConfigPresetsError[] = [];
 
     for (const presetFile of presetFiles) {
@@ -46,22 +47,24 @@ export async function loadPresets(dirPath: string, config: Config): Promise<Pres
                 preset.thumbnail = resolveThumbnailPath(preset.thumbnail, presetsRelDir);
             }
             _.set(preset, 'modelName', presetData.model);
-            append(presetsByModel, presetData.model, presetId);
+            append(presetsIdsByModel, presetData.model, presetId);
         });
     }
 
-    // update config with presets
-    for (const model of config.models) {
-        const presetsForModel = presetsByModel[model.name];
-        if (presetsForModel) {
-            model.presets = presetsForModel;
+    // update models with presets IDs
+    const models = _.map(config.models, (model) => {
+        const presetIdsForModel = presetsIdsByModel[model.name];
+        if (!presetIdsForModel) {
+            return model;
         }
-    }
-
-    config.presets = presets;
+        return { ...model, presets: presetIdsForModel };
+    });
 
     return {
-        config,
+        config: Object.assign({}, config, {
+            models,
+            presets
+        }),
         errors
     };
 }

package/src/content/content-loader.ts

@@ -10,7 +10,7 @@ import {
     isDataModel,
     isPageModel,
     getModelsByQuery,
-    getListItemsField,
+    getListFieldItems,
     isListField,
     isModelField,
     isListDataModel,
@@ -480,7 +480,7 @@ function addMetadataRecursively({
         } else if (_.isArray(value)) {
             let fieldListItems: FieldListItems;
             if (field && isListField(field)) {
-                fieldListItems = getListItemsField(field);
+                fieldListItems = getListFieldItems(field);
             } else if (model && isListDataModel(model)) {
                 fieldListItems = model.items;
             } else {

package/src/content/content-schema.ts

@@ -106,6 +106,10 @@ function joiSchemaForModelFields(fields: Field[] | undefined, config: Config, fi
     );
 }
 
+function assertUnreachable(field: never): never {
+    throw new Error('Unhandled field.type case');
+}
+
 function joiSchemaForField(field: Field | FieldListItems, config: Config, fieldPath: FieldPath) {
     let fieldSchema;
     switch (field.type) {
@@ -148,6 +152,11 @@ function joiSchemaForField(field: Field | FieldListItems, config: Config, fieldP
         case 'list':
             fieldSchema = listFieldValueSchema(field, config, fieldPath);
             break;
+        case 'json':
+        case 'richText':
+            return Joi.any().forbidden();
+        default:
+            assertUnreachable(field);
     }
     if ('const' in field) {
         fieldSchema = fieldSchema.valid(field.const).invalid(null, '').required();

package/src/utils/model-extender.ts

@@ -11,7 +11,7 @@ export function extendModelArray(models: Model[]): { models: Model[]; errors: Co
         models,
         (result: { models: Model[]; errors: ConfigValidationError[] }, model) => {
             // YamlModel is the same as Model just without 'name' and '__metadata' properties
-            const { model: extendedModel, errors } = memorized(model, model.name, modelsByName);
+            const { model: extendedModel, errors } = memorized(model, model.name, modelsByName as ModelMap);
             return {
                 models: result.models.concat(extendedModel),
                 errors: result.errors.concat(errors)

package/src/utils/model-iterators.ts

@@ -1,7 +1,7 @@
 import _ from 'lodash';
 
-import { getListItemsField, isListDataModel, isListField, isObjectListItems, isModelField, isObjectField, isModelListItems } from './model-utils';
-import { Field, FieldListItems, FieldModelProps, Model } from '../config/config-types';
+import { getListFieldItems, isListDataModel, isListField, isObjectListItems, isModelField, isObjectField, isModelListItems } from './model-utils';
+import { DataModel, Field, FieldList, FieldListItems, FieldModelProps, FieldObjectProps, Model } from '../config/config-types';
 
 /**
  * This function invokes the `iteratee` function for every field of the `model`.
@@ -39,24 +39,24 @@ import { Field, FieldListItems, FieldModelProps, Model } from '../config/config-
  * @param model The model to iterate fields
  * @param iteratee The callback function
  */
-export function iterateModelFieldsRecursively(model: Model, iteratee: (field: Field, fieldPath: string[]) => void) {
-    function _iterateDeep({ fields, fieldPath }: { fields: Field[]; fieldPath: string[] }) {
-        fieldPath = fieldPath.concat('fields');
+export function iterateModelFieldsRecursively(model: Model, iteratee: (field: Field, modelKeyPath: string[]) => void) {
+    function _iterateDeep({ fields, modelKeyPath }: { fields: Field[]; modelKeyPath: string[] }) {
+        modelKeyPath = modelKeyPath.concat('fields');
         _.forEach(fields, (field) => {
             if (!field) {
                 return;
             }
-            const childFieldPath = fieldPath.concat(field.name);
-            iteratee(field, childFieldPath);
+            const childModelKeyPath = modelKeyPath.concat(field.name);
+            iteratee(field, childModelKeyPath);
             if (isObjectField(field)) {
                 _iterateDeep({
                     fields: field.fields,
-                    fieldPath: childFieldPath
+                    modelKeyPath: childModelKeyPath
                 });
             } else if (isListField(field) && field.items && isObjectListItems(field.items)) {
                 _iterateDeep({
                     fields: field.items?.fields,
-                    fieldPath: childFieldPath.concat('items')
+                    modelKeyPath: childModelKeyPath.concat('items')
                 });
             }
         });
@@ -65,16 +65,64 @@ export function iterateModelFieldsRecursively(model: Model, iteratee: (field: Fi
     if (model && isListDataModel(model) && model.items && isObjectListItems(model.items)) {
         _iterateDeep({
             fields: model.items?.fields,
-            fieldPath: ['items']
+            modelKeyPath: ['items']
         });
     } else {
         _iterateDeep({
             fields: model?.fields || [],
-            fieldPath: []
+            modelKeyPath: []
         });
     }
 }
 
+export function mapModelFieldsRecursively(model: Model, iteratee: (field: Field, modelKeyPath: string[]) => Field) {
+    function _mapField(field: Field, modelKeyPath: string[]): Field {
+        if (!field) {
+            return field;
+        }
+        modelKeyPath = modelKeyPath.concat(field.name);
+        field = iteratee(field, modelKeyPath);
+        if (isObjectField(field)) {
+            return _mapObjectField(field, modelKeyPath);
+        } else if (isListField(field)) {
+            return _mapListField(field, modelKeyPath);
+        } else {
+            return field;
+        }
+    }
+
+    function _mapObjectField<T extends FieldObjectProps | Model>(field: T, modelKeyPath: string[]): T {
+        const fields = field.fields;
+        if (!fields) {
+            return field;
+        }
+        modelKeyPath = modelKeyPath.concat('fields');
+        return {
+            ...field,
+            fields: _.map(fields, (field) => _mapField(field, modelKeyPath))
+        };
+    }
+
+    function _mapListField<T extends FieldList | (DataModel & { isList: true })>(field: T, modelKeyPath: string[]): T {
+        const items = field.items;
+        if (!items || !isObjectListItems(items)) {
+            return field;
+        }
+        return {
+            ...field,
+            items: _mapObjectField(items, modelKeyPath.concat('items'))
+        };
+    }
+
+    if (!model) {
+        return model;
+    } else if (isListDataModel(model)) {
+        return _mapListField(model, []);
+    } else {
+        return _mapObjectField(model, []);
+    }
+}
+
 export function iterateObjectFieldsWithModelRecursively(
     value: any,
     model: Model,
@@ -165,7 +213,7 @@ export function iterateObjectFieldsWithModelRecursively(
         } else if (_.isArray(value)) {
             let fieldListItems: FieldListItems | null = null;
             if (field && isListField(field)) {
-                fieldListItems = getListItemsField(field);
+                fieldListItems = getListFieldItems(field);
             } else if (model && isListDataModel(model)) {
                 fieldListItems = model.items;
             }
@@ -287,7 +335,7 @@ export function mapObjectFieldsWithModelRecursively(
         } else if (_.isArray(value)) {
             let fieldListItems: FieldListItems | null = null;
             if (field && isListField(field)) {
-                fieldListItems = getListItemsField(field);
+                fieldListItems = getListFieldItems(field);
             } else if (model && isListDataModel(model)) {
                 fieldListItems = model.items;
             }

package/src/utils/model-utils.ts

@@ -79,20 +79,20 @@ export function isEnumField(field: Field): field is FieldEnum {
 }
 
 export function isListOfObjectsField(field: Field): field is FieldListObject {
-    return isListField(field) && isObjectListItems(getListItemsField(field));
+    return isListField(field) && isObjectListItems(getListFieldItems(field));
 }
 
 export function isListOfModelsField(field: Field): field is FieldListModel {
-    return isListField(field) && isModelListItems(getListItemsField(field));
+    return isListField(field) && isModelListItems(getListFieldItems(field));
 }
 
 export function isListOfReferencesField(field: Field): field is FieldListReference {
-    return isListField(field) && isReferenceListItems(getListItemsField(field));
+    return isListField(field) && isReferenceListItems(getListFieldItems(field));
 }
 
 export function isListOfCustomModelsField(field: Field, modelsByName?: Record<string, Model>): field is FieldList {
     // custom model field types are deprecated
-    return isListField(field) && isCustomModelListItems(getListItemsField(field), modelsByName);
+    return isListField(field) && isCustomModelListItems(getListFieldItems(field), modelsByName);
 }
 
 export function isListField(field: Field): field is FieldList {
@@ -122,7 +122,7 @@ export function isCustomModelListItems(items: FieldListItems, modelsByName?: Rec
  * items field, the default field is string:
  *
  * @example
- * listItemField = getListItemsField({
+ * listItemField = getListFieldItems({
  *   type: 'list',
  *   name: '...',
  *   items: { type: 'object', fields: [] }
@@ -134,15 +134,36 @@ export function isCustomModelListItems(items: FieldListItems, modelsByName?: Rec
  * }
  *
  * // list field without `items`
- * listItemField = getListItemsField({ type: 'list', name: '...' }
+ * listItemField = getListFieldItems({ type: 'list', name: '...' }
  * listItemField => { type: 'string' }
  *
  * @param {Object} field
  * @return {Object}
  */
-export function getListItemsField(field: FieldList): FieldListItems {
+export function getListFieldItems(field: FieldList): FieldListItems {
     // items.type defaults to string
-    return _.defaults(field.items, { type: 'string' });
+    return Object.assign({ type: 'string' }, field.items);
+}
+
+export function normalizeListField(field: FieldList): FieldList {
+    if (field.items?.type) {
+        return field;
+    }
+    return {
+        ...field,
+        items: {
+            type: 'string',
+            ...(field.items ?? {})
+        }
+    };
+}
+
+export function normalizeListFieldInPlace(field: FieldList): FieldList {
+    // 'items.type' of list field default to 'string', set it explicitly
+    if (!_.has(field, 'items.type')) {
+        _.set(field, 'items.type', 'string');
+    }
+    return field;
 }
 
 export function assignLabelFieldIfNeeded(modelOrField: Model | FieldObjectProps) {
@@ -176,3 +197,65 @@ export function resolveLabelFieldForModel(modelOrField: Model | FieldObjectProps
     }
     return labelField || null;
 }
+
+export function getModelFieldForModelKeyPath(model: Model, modelKeyPath: string[]) {
+    function _getField(field: Field, modelKeyPath: string[]): Model | Field | FieldListItems | FieldObjectProps | null {
+        if (modelKeyPath.length === 0) {
+            return field;
+        } else if (isObjectField(field)) {
+            return _getObjectFields(field, modelKeyPath);
+        } else if (isListField(field)) {
+            return _getListItems(field, modelKeyPath);
+        } else {
+            return null;
+        }
+    }
+
+    function _getObjectFields<T extends FieldObjectProps | Model>(field: T, modelKeyPath: string[]): Model | Field | FieldListItems | FieldObjectProps | null {
+        if (modelKeyPath.length === 0) {
+            return field;
+        }
+        const key = modelKeyPath.shift();
+        if (key !== 'fields' || !field.fields) {
+            return null;
+        }
+        if (modelKeyPath.length === 0) {
+            return null;
+        }
+        const fieldName = modelKeyPath.shift();
+        const childField = _.find(field.fields, (field) => field.name === fieldName);
+        if (!childField) {
+            return null;
+        }
+        return _getField(childField, modelKeyPath);
+    }
+
+    function _getListItems<T extends FieldList | (DataModel & { isList: true })>(
+        field: T,
+        modelKeyPath: string[]
+    ): Model | Field | FieldListItems | FieldObjectProps | null {
+        if (modelKeyPath.length === 0) {
+            return field;
+        }
+        const key = modelKeyPath.shift();
+        if (key !== 'items' || !field.items) {
+            return null;
+        }
+        if (modelKeyPath.length === 0) {
+            return field.items;
+        }
+        if (!isObjectListItems(field.items)) {
+            return null;
+        }
+        return _getObjectFields(field.items, modelKeyPath);
+    }
+
+    modelKeyPath = modelKeyPath.slice();
+    if (!model) {
+        return null;
+    } else if (isListDataModel(model)) {
+        return _getListItems(model, modelKeyPath);
+    } else {
+        return _getObjectFields(model, modelKeyPath);
+    }
+}