@stackbit/sdk 0.3.5 → 0.3.6

package/dist/config/config-loader.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadConfigFromDir = exports.validateAndNormalizeConfig = exports.extendConfig = exports.loadConfig = void 0;
+exports.mergeConfigModelsWithExternalModels = exports.loadConfigFromDir = exports.validateAndNormalizeConfig = exports.loadAndMergeModelsFromFiles = exports.loadConfig = exports.loadConfigWithModels = exports.loadConfigWithModelsPresetsAndValidate = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const chokidar_1 = __importDefault(require("chokidar"));
@@ -35,29 +35,91 @@ const config_loader_esbuild_1 = require("./config-loader-esbuild");
 const utils_2 = require("../utils");
 const presets_loader_1 = require("./presets-loader");
 const config_loader_utils_1 = require("./config-loader-utils");
-async function loadConfig({ dirPath, modelsSource, stackbitConfigESBuildOutDir, watchCallback, logger }) {
-    let wrappedCallback;
-    if (watchCallback) {
-        wrappedCallback = async (rawConfigResult) => {
-            const configLoaderResult = await processConfigLoaderResult({ rawConfigResult, dirPath, modelsSource });
-            watchCallback(configLoaderResult);
+async function loadConfigWithModelsPresetsAndValidate({ dirPath, modelsSource, stackbitConfigESBuildOutDir, watchCallback, logger }) {
+    const configResult = await loadConfigWithModels({
+        dirPath,
+        stackbitConfigESBuildOutDir,
+        watchCallback: watchCallback
+            ? async (configResult) => {
+                const configLoaderResult = await processConfigLoaderResult({ configResult, dirPath, modelsSource });
+                watchCallback(configLoaderResult);
+            }
+            : undefined,
+        logger
+    });
+    const configLoaderResult = await processConfigLoaderResult({ configResult, dirPath, modelsSource });
+    return {
+        ...configLoaderResult,
+        stop: configResult.stop,
+        reload: configResult.reload
+    };
+}
+exports.loadConfigWithModelsPresetsAndValidate = loadConfigWithModelsPresetsAndValidate;
+async function loadConfigWithModels({ dirPath, stackbitConfigESBuildOutDir, watchCallback, logger }) {
+    const wrapConfigResult = async (configResult) => {
+        if (!configResult.config) {
+            return {
+                config: null,
+                errors: configResult.errors
+            };
+        }
+        return await loadAndMergeModelsFromFiles(configResult.config);
+    };
+    const rawConfigResult = await loadConfig({
+        dirPath,
+        stackbitConfigESBuildOutDir,
+        logger,
+        watchCallback: watchCallback
+            ? async (configResult) => {
+                const wrappedResult = await wrapConfigResult(configResult);
+                watchCallback(wrappedResult);
+            }
+            : undefined
+    });
+    const wrappedResult = await wrapConfigResult(rawConfigResult);
+    return {
+        ...wrappedResult,
+        stop: rawConfigResult.stop,
+        reload: rawConfigResult.reload
+    };
+}
+exports.loadConfigWithModels = loadConfigWithModels;
+async function loadConfig({ dirPath, stackbitConfigESBuildOutDir, watchCallback, logger }) {
+    const normalizeConfigResult = (rawConfigResult) => {
+        if (!rawConfigResult.config) {
+            return {
+                config: null,
+                errors: [rawConfigResult.error]
+            };
+        }
+        // TODO: validate config base properties after normalizing and return validation errors
+        const config = normalizeConfig(rawConfigResult.config);
+        return {
+            config: config,
+            errors: []
         };
-    }
+    };
     const rawConfigResult = await loadConfigFromDir({
         dirPath,
         stackbitConfigESBuildOutDir,
-        watchCallback: wrappedCallback,
+        watchCallback: watchCallback
+            ? async (rawConfigResult) => {
+                const normalizedResult = await normalizeConfigResult(rawConfigResult);
+                watchCallback(normalizedResult);
+            }
+            : undefined,
         logger
     });
-    const configLoaderResult = await processConfigLoaderResult({ rawConfigResult, dirPath, modelsSource });
-    return Object.assign(configLoaderResult, {
+    const normalizedResult = await normalizeConfigResult(rawConfigResult);
+    return {
+        ...normalizedResult,
         stop: rawConfigResult.stop,
         reload: rawConfigResult.reload
-    });
+    };
 }
 exports.loadConfig = loadConfig;
-async function processConfigLoaderResult({ rawConfigResult, dirPath, modelsSource }) {
-    const { config, errors: configLoadErrors } = rawConfigResult;
+async function processConfigLoaderResult({ configResult, dirPath, modelsSource }) {
+    const { config, errors: configLoadErrors } = configResult;
     if (!config) {
         return {
             valid: false,
@@ -66,76 +128,95 @@ async function processConfigLoaderResult({ rawConfigResult, dirPath, modelsSourc
         };
     }
     const { models: externalModels, errors: externalModelsLoadErrors } = await loadModelsFromExternalSource(config, dirPath, modelsSource);
-    const extendedConfig = await extendConfig({ config, externalModels });
-    return {
-        valid: extendedConfig.valid,
-        config: extendedConfig.config,
-        errors: [...configLoadErrors, ...externalModelsLoadErrors, ...extendedConfig.errors]
+    const mergedModels = mergeConfigModelsWithExternalModels({ configModels: config.models, externalModels });
+    const mergedConfig = {
+        ...config,
+        models: mergedModels
+    };
+    const normalizedResult = validateAndNormalizeConfig(mergedConfig);
+    const presetsResult = await presets_loader_1.loadPresets({ config: normalizedResult.config });
+    const modelsWithPresetIds = presets_loader_1.extendModelsWithPresetsIds({
+        models: normalizedResult.config.models,
+        presets: presetsResult.presets
+    });
+    const configWithPresets = {
+        ...normalizedResult.config,
+        models: modelsWithPresetIds,
+        presets: presetsResult.presets
     };
-}
-async function extendConfig({ config, externalModels }) {
-    const normalizedResult = validateAndNormalizeConfig(config, externalModels);
-    const presetsResult = await presets_loader_1.loadPresets(config.dirPath, normalizedResult.config);
     return {
         valid: normalizedResult.valid,
-        config: presetsResult.config,
-        errors: [...normalizedResult.errors, ...presetsResult.errors]
+        config: configWithPresets,
+        errors: [...configLoadErrors, ...externalModelsLoadErrors, ...normalizedResult.errors, ...presetsResult.errors]
     };
 }
-exports.extendConfig = extendConfig;
-function validateAndNormalizeConfig(config, externalModels) {
-    // extend config models having the "extends" property
-    // this must be done before any validation as some properties like
-    // the labelField will not work when validating models without extending them first
-    const { models: extendedModels, errors: extendModelErrors } = utils_2.extendModelMap(config.models);
+async function loadAndMergeModelsFromFiles(config) {
+    const { models: modelsFromFiles, errors: fileModelsErrors } = await config_loader_utils_1.loadYamlModelsFromFiles(config);
+    const { models: mergedModels, errors: mergeModelErrors } = config_loader_utils_1.mergeConfigModelsWithModelsFromFiles(config.models, modelsFromFiles);
     const extendedConfig = {
         ...config,
-        models: extendedModels
+        models: mergedModels
+    };
+    return {
+        config: extendedConfig,
+        errors: [...fileModelsErrors, ...mergeModelErrors]
     };
-    const { config: mergedConfig, errors: externalModelsMergeErrors } = mergeConfigWithExternalModels(extendedConfig, externalModels);
+}
+exports.loadAndMergeModelsFromFiles = loadAndMergeModelsFromFiles;
+function validateAndNormalizeConfig(config) {
     // validate the "contentModels" and extend config models with "contentModels"
     // this must be done before main config validation to make it independent of "contentModels".
-    const { value: configWithContentModels, errors: contentModelsErrors } = validateAndExtendContentModels(mergedConfig);
+    const { config: configWithContentModels, errors: contentModelsErrors } = validateAndExtendContentModels(config);
     // normalize config - backward compatibility updates, adding extra fields like "markdown_content", "type" and "layout",
     // and setting other default values.
-    const normalizedConfig = normalizeConfig(configWithContentModels);
+    const configWithNormalizedModels = normalizeModels(configWithContentModels);
     // validate config
-    const { value: validatedConfig, errors: validationErrors } = config_validator_1.validateConfig(normalizedConfig);
-    const errors = [...extendModelErrors, ...externalModelsMergeErrors, ...contentModelsErrors, ...validationErrors];
+    const { config: validatedConfig, errors: validationErrors } = config_validator_1.validateConfig(configWithNormalizedModels);
+    const errors = [...contentModelsErrors, ...validationErrors];
     return normalizeValidationResult({
         valid: lodash_1.default.isEmpty(errors),
-        value: validatedConfig,
+        config: validatedConfig,
         errors: errors
     });
 }
 exports.validateAndNormalizeConfig = validateAndNormalizeConfig;
 async function loadConfigFromDir({ dirPath, stackbitConfigESBuildOutDir, watchCallback, logger }) {
+    function wrapResult(result, configFilePath) {
+        if (result.error) {
+            return {
+                config: null,
+                error: result.error
+            };
+        }
+        else {
+            return {
+                config: {
+                    ...result.config,
+                    dirPath: dirPath,
+                    filePath: configFilePath
+                },
+                error: null
+            };
+        }
+    }
     // try to load stackbit config from YAML files
     try {
         const stackbitYamlPath = await utils_1.getFirstExistingFile(config_loader_utils_1.STACKBIT_CONFIG_YAML_FILES, dirPath);
         if (stackbitYamlPath) {
-            const { config, errors } = await config_loader_utils_1.loadConfigWithModelsFromDir(dirPath);
+            logger === null || logger === void 0 ? void 0 : logger.debug(`loading Stackbit configuration from ${stackbitYamlPath}`);
+            const result = await config_loader_utils_1.loadStackbitYamlFromDir(dirPath);
             let close = async () => void 0;
             let reload = () => void 0;
             let stopped = false;
             if (watchCallback) {
-                const watcher = chokidar_1.default.watch([...config_loader_utils_1.STACKBIT_CONFIG_YAML_FILES, '.stackbit'], {
+                const watcher = chokidar_1.default.watch([...config_loader_utils_1.STACKBIT_CONFIG_YAML_FILES], {
                     cwd: dirPath,
                     persistent: true,
                     ignoreInitial: true
                 });
                 const throttledFileChange = lodash_1.default.throttle(async () => {
-                    const { config, errors } = await config_loader_utils_1.loadConfigWithModelsFromDir(dirPath);
-                    watchCallback({
-                        config: config
-                            ? {
-                                ...config,
-                                dirPath: dirPath,
-                                filePath: stackbitYamlPath
-                            }
-                            : undefined,
-                        errors
-                    });
+                    const result = await config_loader_utils_1.loadStackbitYamlFromDir(dirPath);
+                    watchCallback(wrapResult(result, stackbitYamlPath));
                 }, 1000);
                 const handleFileChange = (path) => {
                     logger === null || logger === void 0 ? void 0 : logger.debug(`identified change in stackbit config file: ${path}, reloading config...`);
@@ -148,7 +229,8 @@ async function loadConfigFromDir({ dirPath, stackbitConfigESBuildOutDir, watchCa
                 watcher.on('unlinkDir', handleFileChange);
                 watcher.on('error', (error) => {
                     watchCallback({
-                        errors: [new config_errors_1.ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })]
+                        config: null,
+                        error: new config_errors_1.ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })
                     });
                 });
                 close = async () => {
@@ -164,45 +246,23 @@ async function loadConfigFromDir({ dirPath, stackbitConfigESBuildOutDir, watchCa
                 };
             }
             return {
-                config: config
-                    ? {
-                        ...config,
-                        dirPath: dirPath,
-                        filePath: stackbitYamlPath
-                    }
-                    : undefined,
+                ...wrapResult(result, stackbitYamlPath),
                 stop: close,
-                reload: reload,
-                errors: errors
+                reload: reload
             };
         }
     }
     catch (error) {
         return {
-            errors: [new config_errors_1.ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })]
+            config: null,
+            error: new config_errors_1.ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })
         };
     }
-    function wrapResult(result, configFilePath) {
-        if (result.error) {
-            return {
-                errors: [result.error]
-            };
-        }
-        else {
-            return {
-                config: {
-                    ...result.config,
-                    dirPath: dirPath,
-                    filePath: configFilePath
-                },
-                errors: []
-            };
-        }
-    }
     // try to load stackbit config from JavaScript files
     try {
         const configFilePath = await utils_1.getFirstExistingFile(config_loader_utils_1.STACKBIT_CONFIG_JS_FILES, dirPath);
         if (configFilePath) {
+            logger === null || logger === void 0 ? void 0 : logger.debug(`loading Stackbit configuration from: ${configFilePath}`);
             const configResult = await config_loader_esbuild_1.loadStackbitConfigFromJs({
                 configPath: configFilePath,
                 outDir: stackbitConfigESBuildOutDir !== null && stackbitConfigESBuildOutDir !== void 0 ? stackbitConfigESBuildOutDir : '.stackbit/cache',
@@ -219,11 +279,13 @@ async function loadConfigFromDir({ dirPath, stackbitConfigESBuildOutDir, watchCa
     }
     catch (error) {
         return {
-            errors: [new config_errors_1.ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })]
+            config: null,
+            error: new config_errors_1.ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })
         };
     }
     return {
-        errors: [new config_errors_1.ConfigLoadError(config_errors_1.STACKBIT_CONFIG_NOT_FOUND)]
+        config: null,
+        error: new config_errors_1.ConfigLoadError(config_errors_1.STACKBIT_CONFIG_NOT_FOUND)
     };
 }
 exports.loadConfigFromDir = loadConfigFromDir;
@@ -285,34 +347,27 @@ async function loadConfigFromDotStackbit(dirPath) {
     }
     return lodash_1.default.isEmpty(config) ? null : config;
 }
-function mergeConfigWithExternalModels(config, externalModels) {
+function mergeConfigModelsWithExternalModels({ configModels, externalModels }) {
     var _a;
-    if (!externalModels || externalModels.length === 0) {
-        return {
-            config,
-            errors: []
-        };
+    if (externalModels.length === 0) {
+        return configModels;
     }
-    const stackbitModels = (_a = config === null || config === void 0 ? void 0 : config.models) !== null && _a !== void 0 ? _a : {};
-    const errors = [];
-    const models = lodash_1.default.reduce(externalModels, (modelMap, externalModel) => {
-        const { name, ...rest } = externalModel;
-        return Object.assign(modelMap, { [name]: rest });
-    }, {});
-    lodash_1.default.forEach(stackbitModels, (stackbitModel, modelName) => {
-        var _a, _b;
-        let externalModel = models[modelName];
+    if (configModels.length === 0) {
+        return externalModels;
+    }
+    const mergedModelsByName = lodash_1.default.keyBy(externalModels, 'name');
+    for (const configModel of configModels) {
+        const externalModel = mergedModelsByName[configModel.name];
         if (!externalModel) {
-            return;
+            continue;
+        }
+        const modelType = configModel.type ? (configModel.type === 'config' ? 'data' : configModel.type) : (_a = externalModel.type) !== null && _a !== void 0 ? _a : 'object';
+        let mergedModel = Object.assign({}, externalModel, lodash_1.default.pick(configModel, ['__metadata', 'urlPath', 'label', 'description', 'thumbnail', 'singleInstance', 'readOnly', 'labelField', 'fieldGroups']), { type: modelType });
+        if (mergedModel.type === 'page' && !mergedModel.urlPath) {
+            mergedModel.urlPath = '/{slug}';
         }
-        const modelType = stackbitModel.type ? (stackbitModel.type === 'config' ? 'data' : stackbitModel.type) : (_a = externalModel.type) !== null && _a !== void 0 ? _a : 'object';
-        const urlPath = modelType === 'page' ? (_b = stackbitModel === null || stackbitModel === void 0 ? void 0 : stackbitModel.urlPath) !== null && _b !== void 0 ? _b : '/{slug}' : null;
-        externalModel = Object.assign({}, externalModel, lodash_1.default.pick(stackbitModel, ['__metadata', 'label', 'description', 'thumbnail', 'singleInstance', 'readOnly', 'labelField', 'fieldGroups']), utils_1.omitByNil({
-            type: modelType,
-            urlPath
-        }));
-        externalModel = utils_2.mapModelFieldsRecursively(externalModel, (externalField, modelKeyPath) => {
-            const stackbitField = utils_2.getModelFieldForModelKeyPath(stackbitModel, modelKeyPath);
+        mergedModel = utils_2.mapModelFieldsRecursively(mergedModel, (externalField, modelKeyPath) => {
+            const stackbitField = utils_2.getModelFieldForModelKeyPath(configModel, modelKeyPath);
             if (!stackbitField) {
                 return externalField;
             }
@@ -332,40 +387,52 @@ function mergeConfigWithExternalModels(config, externalModels) {
             else if (externalField.type === 'object') {
                 override = lodash_1.default.pick(stackbitField, ['labelField', 'thumbnail', 'fieldGroups']);
             }
+            else if (externalField.type === 'reference' || externalField.type === 'model') {
+                override = lodash_1.default.pick(stackbitField, ['models']);
+            }
             return Object.assign({}, externalField, lodash_1.default.pick(stackbitField, ['label', 'description', 'required', 'default', 'group', 'const', 'hidden', 'readOnly', 'controlType']), override);
         });
-        models[modelName] = externalModel;
-    });
+        mergedModelsByName[configModel.name] = mergedModel;
+    }
+    return Object.values(mergedModelsByName);
+}
+exports.mergeConfigModelsWithExternalModels = mergeConfigModelsWithExternalModels;
+function normalizeConfig(rawConfig) {
+    const stackbitVersion = String(lodash_1.default.get(rawConfig, 'stackbitVersion', config_loader_utils_1.LATEST_STACKBIT_VERSION));
+    const ver = semver_1.default.coerce(stackbitVersion);
+    const isGTEStackbitYamlV5 = ver ? semver_1.default.satisfies(ver, '>=0.5.0') : false;
+    const { logicFields, models: modelMap, ...restConfig } = rawConfig;
+    // in stackbit.yaml 'models' are defined as object where keys are the model names,
+    // convert 'models' to array of objects and set their 'name' property to the model name
+    const models = lodash_1.default.reduce(modelMap, (accum, model, modelName) => accum.concat(Object.assign({ name: modelName }, model)), []);
     return {
-        config: {
-            ...config,
-            models: models
-        },
-        errors: errors
+        ...restConfig,
+        stackbitVersion: stackbitVersion,
+        models: models,
+        noEncodeFields: logicFields,
+        hcrHandled: !stackbitVersion || lodash_1.default.get(rawConfig, 'customContentReload', lodash_1.default.get(rawConfig, 'hcrHandled', !isGTEStackbitYamlV5)),
+        internalStackbitRunnerOptions: getInternalStackbitRunnerOptions(rawConfig)
     };
 }
-function normalizeConfig(config) {
-    const pageLayoutKey = lodash_1.default.get(config, 'pageLayoutKey', 'layout');
-    const objectTypeKey = lodash_1.default.get(config, 'objectTypeKey', 'type');
-    const stackbitYamlVersion = String(lodash_1.default.get(config, 'stackbitVersion', ''));
+function normalizeModels(config) {
+    var _a, _b, _c;
+    const pageLayoutKey = (_a = config.pageLayoutKey) !== null && _a !== void 0 ? _a : 'layout';
+    const objectTypeKey = (_b = config.objectTypeKey) !== null && _b !== void 0 ? _b : 'type';
+    const stackbitYamlVersion = String((_c = config.stackbitVersion) !== null && _c !== void 0 ? _c : '');
     const ver = semver_1.default.coerce(stackbitYamlVersion);
     const isStackbitYamlV2 = ver ? semver_1.default.satisfies(ver, '<0.3.0') : false;
-    const isStackbitYamlV5 = ver ? semver_1.default.satisfies(ver, '>=0.5.0') : false;
-    const models = (config === null || config === void 0 ? void 0 : config.models) || {};
+    const models = config.models;
+    const modelsByName = lodash_1.default.keyBy(models, 'name');
     const gitCMS = isGitCMS(config);
-    utils_1.rename(config, 'logicFields', 'noEncodeFields');
-    config.hcrHandled = !stackbitYamlVersion || lodash_1.default.get(config, 'customContentReload', lodash_1.default.get(config, 'hcrHandled', !isStackbitYamlV5));
-    config.internalStackbitRunnerOptions = getInternalStackbitRunnerOptions(config);
-    lodash_1.default.forEach(models, (model, modelName) => {
-        if (!model) {
-            return;
-        }
+    const mappedModels = models.map((model) => {
+        // create shallow copy of the model to prevent mutation of original models
+        model = { ...model };
         if (!lodash_1.default.has(model, 'type')) {
             model.type = 'object';
         }
         // add model label if not set
         if (!lodash_1.default.has(model, 'label')) {
-            model.label = lodash_1.default.startCase(modelName);
+            model.label = lodash_1.default.startCase(model.name);
         }
         if (lodash_1.default.has(model, 'fields') && !Array.isArray(model.fields)) {
             model.fields = [];
@@ -387,17 +454,15 @@ function normalizeConfig(config) {
             //  The content validator should always assume these fields.
             //  And when new objects created from UI, it should add these fields automatically.
             if (utils_2.isPageModel(model)) {
-                addLayoutFieldToPageModel(model, pageLayoutKey, modelName);
+                addLayoutFieldToPageModel(model, pageLayoutKey, model.name);
             }
             else if (utils_2.isDataModel(model) && !utils_2.isListDataModel(model)) {
-                addObjectTypeKeyField(model, objectTypeKey, modelName);
+                addObjectTypeKeyField(model, objectTypeKey, model.name);
             }
         }
         if (utils_2.isListDataModel(model)) {
             // 'items.type' of list model defaults to 'string', set it explicitly
-            if (!lodash_1.default.has(model, 'items.type')) {
-                lodash_1.default.set(model, 'items.type', 'string');
-            }
+            utils_2.normalizeListFieldInPlace(model);
             if (utils_2.isObjectListItems(model.items)) {
                 utils_2.assignLabelFieldIfNeeded(model.items);
             }
@@ -405,50 +470,65 @@ function normalizeConfig(config) {
         else if (!lodash_1.default.has(model, 'labelField')) {
             utils_2.assignLabelFieldIfNeeded(model);
         }
-        utils_2.iterateModelFieldsRecursively(model, (field) => {
+        return utils_2.mapModelFieldsRecursively(model, (field) => {
+            // create shallow copy of the field to prevent mutation of original field
+            field = { ...field };
             // add field label if label is not set
             if (!lodash_1.default.has(field, 'label')) {
                 field.label = lodash_1.default.startCase(field.name);
             }
-            if (utils_2.isListField(field)) {
-                field = utils_2.normalizeListFieldInPlace(field);
-                field = field.items;
-            }
-            if (utils_2.isObjectField(field)) {
-                utils_2.assignLabelFieldIfNeeded(field);
-            }
-            else if (utils_2.isCustomModelField(field, models)) {
-                // stackbit v0.2.0 compatibility
-                // convert the old custom model field type: { type: 'action' }
-                // to the new 'model' field type: { type: 'model', models: ['action'] }
-                field.models = [field.type];
-                field.type = 'model';
-            }
-            else if (field.type === 'models') {
-                // stackbit v0.2.0 compatibility
-                // convert the old 'models' field type: { type: 'models', models: ['link', 'button'] }
-                // to the new 'model' field type: { type: 'model', models: ['link', 'button'] }
-                field.type = 'model';
-                field.models = lodash_1.default.get(field, 'models', []);
-            }
-            else if (field.type === 'model' && lodash_1.default.has(field, 'model')) {
-                // stackbit v0.2.0 compatibility
-                // convert the old 'model' field type: { type: 'model', model: 'link' }
-                // to the new 'model' field type: { type: 'model', models: ['link'] }
-                field.models = [field.model];
-                delete field.model;
-            }
-            if (isStackbitYamlV2) {
-                // in stackbit.yaml v0.2.x, the 'reference' field was what we have today as 'model' field:
-                if (utils_2.isReferenceField(field)) {
-                    field = field;
-                    field.type = 'model';
-                    field.models = lodash_1.default.get(field, 'models', []);
+            return utils_2.mapListItemsPropsOrSelfSpecificProps(field, (fieldSpecificProps) => {
+                if (utils_2.isObjectField(fieldSpecificProps)) {
+                    utils_2.assignLabelFieldIfNeeded(fieldSpecificProps);
                 }
-            }
+                else if (utils_2.isCustomModelField(fieldSpecificProps, modelsByName)) {
+                    // stackbit v0.2.0 compatibility
+                    // convert the old custom model field type: { type: 'action' }
+                    // to the new 'model' field type: { type: 'model', models: ['action'] }
+                    fieldSpecificProps = {
+                        ...fieldSpecificProps,
+                        type: 'model',
+                        models: [fieldSpecificProps.type]
+                    };
+                }
+                else if (fieldSpecificProps.type === 'models') {
+                    // stackbit v0.2.0 compatibility
+                    // convert the old 'models' field type: { type: 'models', models: ['link', 'button'] }
+                    // to the new 'model' field type: { type: 'model', models: ['link', 'button'] }
+                    fieldSpecificProps = {
+                        ...fieldSpecificProps,
+                        type: 'model',
+                        models: lodash_1.default.get(fieldSpecificProps, 'models', [])
+                    };
+                }
+                else if (fieldSpecificProps.type === 'model' && lodash_1.default.has(fieldSpecificProps, 'model')) {
+                    // stackbit v0.2.0 compatibility
+                    // convert the old 'model' field type: { type: 'model', model: 'link' }
+                    // to the new 'model' field type: { type: 'model', models: ['link'] }
+                    const { model, ...rest } = fieldSpecificProps;
+                    fieldSpecificProps = {
+                        ...rest,
+                        models: [model]
+                    };
+                }
+                if (isStackbitYamlV2) {
+                    // in stackbit.yaml v0.2.x, the 'reference' field was what we have today as 'model' field:
+                    if (utils_2.isReferenceField(fieldSpecificProps)) {
+                        fieldSpecificProps = {
+                            ...fieldSpecificProps,
+                            type: 'model',
+                            models: lodash_1.default.get(fieldSpecificProps, 'models', [])
+                        };
+                    }
+                }
+                return fieldSpecificProps;
+            });
         });
     });
-    return config;
+    return {
+        ...config,
+        models: mappedModels
+    };
 }
 function updatePageUrlPath(model) {
     // set default urlPath if not set
@@ -553,26 +633,23 @@ function addObjectTypeKeyField(model, objectTypeKey, modelName) {
 }
 /**
  * Returns model names referenced by polymorphic 'model' and 'reference' fields.
- * That is, fields that can hold objects of different types.
  *
  * @param field
  */
 function getReferencedModelNames(field) {
     var _a, _b;
-    if (utils_2.isListField(field)) {
-        field = utils_2.getListFieldItems(field);
-    }
+    const fieldSpecificProps = utils_2.getListItemsOrSelf(field);
     // TODO: add type field to model fields inside container update/create object logic rather adding type to schema
     // 'object' models referenced by 'model' fields should have 'type' field
     // if these fields have than 1 model.
     // 'data' models referenced by 'reference' fields should always have 'type' field.
     let referencedModelNames = [];
-    if (utils_2.isModelField(field) && ((_a = field.models) === null || _a === void 0 ? void 0 : _a.length) > 1) {
-        const modelNames = field.models;
+    if (utils_2.isModelField(fieldSpecificProps) && ((_a = fieldSpecificProps.models) === null || _a === void 0 ? void 0 : _a.length) > 1) {
+        const modelNames = fieldSpecificProps.models;
         referencedModelNames = lodash_1.default.union(referencedModelNames, modelNames);
     }
-    else if (utils_2.isReferenceField(field) && ((_b = field.models) === null || _b === void 0 ? void 0 : _b.length) > 0) {
-        const modelNames = field.models;
+    else if (utils_2.isReferenceField(fieldSpecificProps) && ((_b = fieldSpecificProps.models) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+        const modelNames = fieldSpecificProps.models;
         referencedModelNames = lodash_1.default.union(referencedModelNames, modelNames);
     }
     return referencedModelNames;
@@ -580,46 +657,47 @@ function getReferencedModelNames(field) {
 function validateAndExtendContentModels(config) {
     var _a, _b;
     const contentModels = (_a = config.contentModels) !== null && _a !== void 0 ? _a : {};
-    const models = (_b = config.models) !== null && _b !== void 0 ? _b : {};
+    const models = (_b = config.models) !== null && _b !== void 0 ? _b : [];
+    // external models already merged in mergeConfigModelsWithExternalModels function
     const externalModels = !isGitCMS(config);
     const emptyContentModels = lodash_1.default.isEmpty(contentModels);
     if (externalModels || emptyContentModels) {
         return {
-            valid: true,
-            value: config,
+            config: config,
             errors: []
         };
     }
     const validationResult = config_validator_1.validateContentModels(contentModels, models);
     if (lodash_1.default.isEmpty(models)) {
         return {
-            valid: validationResult.valid,
-            value: config,
+            config: config,
             errors: validationResult.errors
         };
     }
-    const extendedModels = lodash_1.default.mapValues(models, (model, modelName) => {
-        const contentModel = validationResult.value.contentModels[modelName];
+    const extendedModels = models.map((model) => {
+        const contentModel = validationResult.contentModels[model.name];
         if (!contentModel) {
             return model;
         }
         if (lodash_1.default.get(contentModel, '__metadata.invalid')) {
             return model;
         }
-        if (contentModel.isPage && (!model.type || ['object', 'page'].includes(model.type))) {
+        const { isPage, newFilePath, ...restContentModel } = contentModel;
+        const { type, ...restModel } = model;
+        if (isPage && (!type || ['object', 'page'].includes(type))) {
             return {
                 type: 'page',
-                ...(contentModel.newFilePath ? { filePath: contentModel.newFilePath } : {}),
-                ...lodash_1.default.omit(contentModel, ['isPage', 'newFilePath']),
-                ...lodash_1.default.omit(model, 'type')
+                ...(newFilePath ? { filePath: newFilePath } : {}),
+                ...restContentModel,
+                ...restModel
             };
         }
-        else if (!contentModel.isPage && (!model.type || ['object', 'data'].includes(model.type))) {
+        else if (!isPage && (!type || ['object', 'data'].includes(type))) {
             return {
                 type: 'data',
-                ...(contentModel.newFilePath ? { filePath: contentModel.newFilePath } : {}),
-                ...lodash_1.default.omit(contentModel, ['isPage', 'newFilePath']),
-                ...lodash_1.default.omit(model, 'type')
+                ...(newFilePath ? { filePath: newFilePath } : {}),
+                ...restContentModel,
+                ...restModel
             };
         }
         else {
@@ -627,8 +705,7 @@ function validateAndExtendContentModels(config) {
         }
     });
     return {
-        valid: validationResult.valid,
-        value: {
+        config: {
             ...config,
             models: extendedModels
         },
@@ -637,14 +714,13 @@ function validateAndExtendContentModels(config) {
 }
 function normalizeValidationResult(validationResult) {
     validationResult = filterAndOrderConfigFields(validationResult);
-    convertModelGroupsToModelList(validationResult);
-    return convertModelsToArray(validationResult);
+    return convertModelGroupsToModelListInPlace(validationResult);
 }
 function filterAndOrderConfigFields(validationResult) {
     // TODO: check if we can move filtering and sorting to Joi
     return {
         ...validationResult,
-        value: lodash_1.default.pick(validationResult.value, [
+        config: lodash_1.default.pick(validationResult.config, [
             'stackbitVersion',
             'ssgName',
             'ssgVersion',
@@ -694,16 +770,16 @@ function filterAndOrderConfigFields(validationResult) {
  * Collects models groups and injects them into the `models` array of the
  * `reference` and `model` field types
  */
-function convertModelGroupsToModelList(validationResult) {
+function convertModelGroupsToModelListInPlace(validationResult) {
     var _a, _b;
-    const models = (_b = (_a = validationResult.value) === null || _a === void 0 ? void 0 : _a.models) !== null && _b !== void 0 ? _b : {};
-    const groupMap = lodash_1.default.reduce(models, (groupMap, model, modelName) => {
+    const models = (_b = (_a = validationResult.config) === null || _a === void 0 ? void 0 : _a.models) !== null && _b !== void 0 ? _b : [];
+    const groupMap = lodash_1.default.reduce(models, (groupMap, model) => {
         if (!model.groups) {
             return groupMap;
         }
         const key = (model === null || model === void 0 ? void 0 : model.type) === 'object' ? 'objectModels' : 'documentModels';
         lodash_1.default.forEach(model.groups, (groupName) => {
-            utils_1.append(groupMap, [groupName, key], modelName);
+            utils_1.append(groupMap, [groupName, key], model.name);
         });
         delete model.groups;
         return groupMap;
@@ -714,78 +790,31 @@ function convertModelGroupsToModelList(validationResult) {
             lodash_1.default.set(group, key, lodash_1.default.uniq(modelGroup));
         });
     });
-    lodash_1.default.forEach(models, (model) => {
-        utils_2.iterateModelFieldsRecursively(model, (field) => {
-            if (utils_2.isListField(field)) {
-                field = field.items;
-            }
-            if (field.groups) {
-                let key = null;
-                if (utils_2.isModelField(field)) {
-                    key = 'objectModels';
-                }
-                else if (utils_2.isReferenceField(field)) {
-                    key = 'documentModels';
+    const mappedModels = models.map((model) => {
+        return utils_2.mapModelFieldsRecursively(model, (field) => {
+            return utils_2.mapListItemsPropsOrSelfSpecificProps(field, (fieldSpecificProps) => {
+                if (!utils_2.isModelField(fieldSpecificProps) && !utils_2.isReferenceField(fieldSpecificProps)) {
+                    return fieldSpecificProps;
                 }
-                if (key) {
-                    field.models = lodash_1.default.reduce(field.groups, (modelNames, groupName) => {
-                        const objectModelNames = lodash_1.default.get(groupMap, [groupName, key], []);
-                        return lodash_1.default.uniq(modelNames.concat(objectModelNames));
-                    }, field.models || []);
-                }
-                delete field.groups;
-            }
+                const { ...cloned } = fieldSpecificProps;
+                const key = utils_2.isModelField(fieldSpecificProps) ? 'objectModels' : 'documentModels';
+                const modelNames = lodash_1.default.reduce(cloned.groups, (modelNames, groupName) => {
+                    const objectModelNames = lodash_1.default.get(groupMap, [groupName, key], []);
+                    return lodash_1.default.uniq(modelNames.concat(objectModelNames));
+                }, fieldSpecificProps.models || []);
+                delete cloned.groups;
+                return Object.assign(cloned, { models: modelNames });
+            });
         });
     });
-}
-function convertModelsToArray(validationResult) {
-    const config = validationResult.value;
-    const { stackbitVersion = config_loader_utils_1.LATEST_STACKBIT_VERSION, models, ...rest } = config;
-    // in stackbit.yaml 'models' are defined as object where keys are the model names,
-    // convert 'models' to array of objects and set their 'name' property to the
-    // model name
-    const modelMap = models !== null && models !== void 0 ? models : {};
-    const modelArray = lodash_1.default.map(modelMap, (yamlModel, modelName) => {
-        return {
-            name: modelName,
-            ...yamlModel
-        };
-    });
-    if (!isGitCMS(config)) {
-        addImageModel(modelArray);
-    }
-    const convertedErrors = lodash_1.default.map(validationResult.errors, (error) => {
-        if (error.fieldPath[0] === 'models' && typeof error.fieldPath[1] == 'string') {
-            const modelName = error.fieldPath[1];
-            const modelIndex = lodash_1.default.findIndex(modelArray, { name: modelName });
-            const normFieldPath = error.fieldPath.slice();
-            normFieldPath[1] = modelIndex;
-            error.normFieldPath = normFieldPath;
-        }
-        return error;
-    });
     return {
-        valid: validationResult.valid,
+        ...validationResult,
         config: {
-            stackbitVersion,
-            ...rest,
-            models: modelArray
-        },
-        errors: convertedErrors
+            ...validationResult.config,
+            models: mappedModels
+        }
     };
 }
-function addImageModel(models) {
-    models.push({
-        type: 'image',
-        name: '__image_model',
-        label: 'Image',
-        labelField: 'title',
-        fields: [
-            { name: 'title', type: 'string' },
-            { name: 'url', type: 'string' }
-        ]
-    });
-}
 function isGitCMS(config) {
     return !config.contentSources && (!config.cmsName || config.cmsName === 'git');
 }