@stackbit/sdk 0.2.22 → 0.2.26

package/src/config/config-schema.ts

@@ -20,7 +20,10 @@ import {
     FieldGroupItem,
     YamlObjectModel,
     ContentModelMap,
-    ContentModel
+    ContentModel,
+    ModelsSourceFiles,
+    ModelsSourceContentful,
+    ModelsSourceSanity
 } from './config-types';
 
 function getConfigFromValidationState(state: Joi.State): YamlConfig {
@@ -200,6 +203,11 @@ const styleObjectModelNotObject = 'styleObjectModelName.model.type';
 const styleObjectModelNameSchema = Joi.string()
     .allow('', null)
     .custom((value, { error, state }) => {
+        const config = getConfigFromValidationState(state);
+        const externalModels = config.cmsName && ['contentful', 'sanity'].includes(config.cmsName);
+        if (externalModels) {
+            return value;
+        }
         const models = getModelsFromValidationState(state);
         const modelNames = Object.keys(models);
         if (!modelNames.includes(value)) {
@@ -245,11 +253,32 @@ const importSchema = Joi.alternatives().conditional('.type', {
     ]
 });
 
-const modelsSourceSchema = Joi.object<ModelsSource>({
-    type: 'files',
+const modelsSourceFilesSchema = Joi.object<ModelsSourceFiles>({
+    type: Joi.string().valid(Joi.override, 'files').required(),
     modelDirs: Joi.array().items(Joi.string()).required()
 });
 
+const modelsSourceContentfulSchema = Joi.object<ModelsSourceContentful>({
+    type: Joi.string().valid(Joi.override, 'contentful').required(),
+    module: Joi.string()
+});
+
+const modelsSourceSanitySchema = Joi.object<ModelsSourceSanity>({
+    type: Joi.string().valid(Joi.override, 'sanity').required(),
+    sanityStudioPath: Joi.string().required(),
+    module: Joi.string()
+});
+
+const modelsSourceSchema = Joi.object<ModelsSource>({
+    type: Joi.string().valid('files', 'contentful', 'sanity').required()
+}).when('.type', {
+    switch: [
+        { is: 'files', then: modelsSourceFilesSchema },
+        { is: 'contentful', then: modelsSourceContentfulSchema },
+        { is: 'sanity', then: modelsSourceSanitySchema }
+    ]
+});
+
 const assetsSchema = Joi.object<Assets>({
     referenceType: Joi.string().valid('static', 'relative').required(),
     assetsDir: Joi.string().allow('').when('referenceType', {
@@ -309,7 +338,8 @@ const fieldCommonPropsSchema = Joi.object({
     group: inGroups,
     const: Joi.any(),
     hidden: Joi.boolean(),
-    readOnly: Joi.boolean()
+    readOnly: Joi.boolean(),
+    localized: Joi.boolean()
 }).oxor('const', 'default');
 
 const numberFieldPartialSchema = Joi.object({

package/src/config/config-types.ts

@@ -3,7 +3,7 @@ import { CMS_NAMES, FIELD_TYPES, SSG_NAMES, STYLE_PROPS } from './config-consts'
 
 export interface Config extends BaseConfig {
     models: Model[];
-    presets?: any;
+    presets?: Record<string, any>;
 }
 
 export interface YamlConfig extends BaseConfig {
@@ -85,16 +85,31 @@ export interface ContentModel extends BaseMatch {
     newFilePath?: string;
 }
 
-export interface ModelsSource {
+export type ModelsSource = ModelsSourceFiles | ModelsSourceContentful | ModelsSourceSanity;
+
+export interface ModelsSourceFiles {
     type: 'files';
     modelDirs: string[];
 }
 
+export interface ModelsSourceContentful {
+    type: 'contentful';
+    module?: string;
+    [key: string]: any;
+}
+
+export interface ModelsSourceSanity {
+    type: 'sanity';
+    sanityStudioPath: string;
+    module?: string;
+    [key: string]: any;
+}
+
 /*******************
  *** Model Types ***
  *******************/
 
-export type Model = StricterUnion<ObjectModel | DataModel | PageModel | ConfigModel>;
+export type Model = StricterUnion<ObjectModel | DataModel | PageModel | ConfigModel | ImageModel>;
 
 export type ObjectModel = YamlObjectModel & BaseModel;
 export type DataModel = YamlDataModel & BaseModel;
@@ -174,6 +189,14 @@ export interface FieldGroupItem {
     label: string;
 }
 
+export interface ImageModel {
+    type: 'image';
+    name: '__image_model';
+    label?: string;
+    labelField?: string;
+    fields?: Field[];
+}
+
 /*******************
  *** Field Types ***
  *******************/
@@ -209,7 +232,7 @@ export interface FieldCommonProps {
 export type FieldType = typeof FIELD_TYPES[number];
 
 export interface FieldSimpleProps {
-    type: 'string' | 'url' | 'slug' | 'text' | 'markdown' | 'html' | 'boolean' | 'date' | 'datetime' | 'color' | 'image' | 'file';
+    type: 'string' | 'url' | 'slug' | 'text' | 'markdown' | 'html' | 'boolean' | 'date' | 'datetime' | 'color' | 'image' | 'file' | 'json' | 'richText';
 }
 
 export type FieldEnumProps = FieldEnumDropdownProps | FieldEnumThumbnailsProps | FieldEnumPaletteProps;

package/src/config/config-writer.ts

@@ -29,6 +29,9 @@ export function convertToYamlConfig({ config }: { config: Config }): YamlConfig
         yamlConfig.models = _.reduce(
             config.models,
             (yamlModels: ModelMap, model: Model) => {
+                if (model.type === 'image') {
+                    return yamlModels;
+                }
                 const yamlModel = _.omit(model, ['name', '__metadata']) as YamlModel;
                 if (yamlModel.type === 'page' && !yamlModel.hideContent && yamlModel.fields) {
                     _.remove(yamlModel.fields, (field) => field.name === 'markdown_content');

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);
+    }
+}