@stackbit/sdk 0.3.5 → 0.3.6

package/src/config/config-loader.ts

@@ -4,33 +4,31 @@ import chokidar from 'chokidar';
 import semver from 'semver';
 import _ from 'lodash';
 
-import { ModelsSource, FieldModel } from '@stackbit/types';
-import { append, getFirstExistingFile, omitByNil, prepend, rename } from '@stackbit/utils';
+import { ModelsSource, Field } from '@stackbit/types';
+import { append, getFirstExistingFile, prepend, rename } from '@stackbit/utils';
 
 import { ConfigValidationResult, validateConfig, validateContentModels } from './config-validator';
-import { ConfigError, ConfigLoadError, ConfigPresetsError, ConfigValidationError, STACKBIT_CONFIG_NOT_FOUND } from './config-errors';
+import { ConfigError, ConfigLoadError, ConfigValidationError, STACKBIT_CONFIG_NOT_FOUND } from './config-errors';
 import { loadStackbitConfigFromJs } from './config-loader-esbuild';
 import {
     assignLabelFieldIfNeeded,
-    extendModelMap,
-    getListFieldItems,
+    getListItemsOrSelf,
     getModelFieldForModelKeyPath,
     isCustomModelField,
     isDataModel,
     isListDataModel,
-    isListField,
     isModelField,
     isObjectField,
     isObjectListItems,
     isPageModel,
     isReferenceField,
-    iterateModelFieldsRecursively,
     mapModelFieldsRecursively,
     normalizeListFieldInPlace,
-    Logger
+    Logger,
+    mapListItemsPropsOrSelfSpecificProps
 } from '../utils';
-import type { Config, Model, SSGRunOptions, YamlModelMap, YamlModel, YamlDataModel, YamlPageModel } from './config-types';
-import { loadPresets } from './presets-loader';
+import type { Config, SSGRunOptions, Model, PageModel, DataModel, DataModelSingle } from './config-types';
+import { extendModelsWithPresetsIds, loadPresets } from './presets-loader';
 import {
     LoadRawConfigResult,
     StopConfigWatch,
@@ -38,77 +36,165 @@ import {
     LATEST_STACKBIT_VERSION,
     STACKBIT_CONFIG_JS_FILES,
     STACKBIT_CONFIG_YAML_FILES,
-    loadConfigWithModelsFromDir
+    loadStackbitYamlFromDir,
+    loadYamlModelsFromFiles,
+    mergeConfigModelsWithModelsFromFiles
 } from './config-loader-utils';
 
-export interface ConfigLoaderOptions {
+export interface ConfigWithModelsPresetsResult {
+    valid: boolean;
+    config: Config | null;
+    errors: ConfigError[];
+}
+
+export async function loadConfigWithModelsPresetsAndValidate({
+    dirPath,
+    modelsSource,
+    stackbitConfigESBuildOutDir,
+    watchCallback,
+    logger
+}: {
     dirPath: string;
     modelsSource?: ModelsSource;
     stackbitConfigESBuildOutDir?: string;
-    watchCallback?: (result: ConfigLoaderResult) => void;
+    watchCallback?: (result: ConfigWithModelsPresetsResult) => void;
     logger?: Logger;
+}): Promise<ConfigWithModelsPresetsResult & StopConfigWatch> {
+    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
+    };
 }
 
-export interface ConfigLoaderResult {
-    valid: boolean;
+export type ConfigWithModelsResult = {
     config: Config | null;
-    errors: ConfigError[];
-}
+    errors: (ConfigLoadError | ConfigValidationError)[];
+};
+
+export async function loadConfigWithModels({
+    dirPath,
+    stackbitConfigESBuildOutDir,
+    watchCallback,
+    logger
+}: {
+    dirPath: string;
+    stackbitConfigESBuildOutDir?: string;
+    watchCallback?: (result: ConfigWithModelsResult) => void;
+    logger?: Logger;
+}): Promise<ConfigWithModelsResult & StopConfigWatch> {
+    const wrapConfigResult = async (configResult: LoadConfigResult): Promise<ConfigWithModelsResult> => {
+        if (!configResult.config) {
+            return {
+                config: null,
+                errors: configResult.errors
+            };
+        }
+        return await loadAndMergeModelsFromFiles(configResult.config);
+    };
 
-export type ConfigLoaderResultWithStop = ConfigLoaderResult & StopConfigWatch;
+    const rawConfigResult = await loadConfig({
+        dirPath,
+        stackbitConfigESBuildOutDir,
+        logger,
+        watchCallback: watchCallback
+            ? async (configResult: LoadConfigResult) => {
+                  const wrappedResult = await wrapConfigResult(configResult);
+                  watchCallback(wrappedResult);
+              }
+            : undefined
+    });
 
-export interface NormalizedValidationResult {
-    valid: boolean;
-    config: Config;
-    errors: ConfigValidationError[];
-}
+    const wrappedResult = await wrapConfigResult(rawConfigResult);
 
-export interface RawConfigLoaderResult {
-    config?: RawConfigWithPaths;
-    errors: ConfigLoadError[];
+    return {
+        ...wrappedResult,
+        stop: rawConfigResult.stop,
+        reload: rawConfigResult.reload
+    };
 }
 
-export type RawConfigLoaderResultWithStop = RawConfigLoaderResult & StopConfigWatch;
+export type LoadConfigResult =
+    | {
+          config: Config;
+          errors: ConfigLoadError[];
+      }
+    | {
+          config: null;
+          errors: ConfigLoadError[];
+      };
 
 export async function loadConfig({
     dirPath,
-    modelsSource,
     stackbitConfigESBuildOutDir,
     watchCallback,
     logger
-}: ConfigLoaderOptions): Promise<ConfigLoaderResultWithStop> {
-    let wrappedCallback: ((rawConfigResult: RawConfigLoaderResult) => Promise<void>) | undefined;
-    if (watchCallback) {
-        wrappedCallback = async (rawConfigResult: RawConfigLoaderResult) => {
-            const configLoaderResult = await processConfigLoaderResult({ rawConfigResult, dirPath, modelsSource });
-            watchCallback(configLoaderResult);
+}: {
+    dirPath: string;
+    stackbitConfigESBuildOutDir?: string;
+    watchCallback?: (result: LoadConfigResult) => void;
+    logger?: Logger;
+}): Promise<LoadConfigResult & StopConfigWatch> {
+    const normalizeConfigResult = (rawConfigResult: RawConfigLoaderResult): LoadConfigResult => {
+        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: RawConfigLoaderResult) => {
+                  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
-    });
+    };
 }
 
 async function processConfigLoaderResult({
-    rawConfigResult,
+    configResult,
     dirPath,
     modelsSource
 }: {
-    rawConfigResult: RawConfigLoaderResult;
+    configResult: ConfigWithModelsResult;
     dirPath: string;
     modelsSource?: ModelsSource;
-}): Promise<ConfigLoaderResult> {
-    const { config, errors: configLoadErrors } = rawConfigResult;
+}): Promise<ConfigWithModelsPresetsResult> {
+    const { config, errors: configLoadErrors } = configResult;
 
     if (!config) {
         return {
@@ -120,67 +206,80 @@ async function processConfigLoaderResult({
 
     const { models: externalModels, errors: externalModelsLoadErrors } = await loadModelsFromExternalSource(config, dirPath, modelsSource);
 
-    const extendedConfig = await extendConfig({ config, externalModels });
+    const mergedModels = mergeConfigModelsWithExternalModels({ configModels: config.models, externalModels });
+    const mergedConfig: Config = {
+        ...config,
+        models: mergedModels
+    };
 
-    return {
-        valid: extendedConfig.valid,
-        config: extendedConfig.config,
-        errors: [...configLoadErrors, ...externalModelsLoadErrors, ...extendedConfig.errors]
+    const normalizedResult = validateAndNormalizeConfig(mergedConfig);
+
+    const presetsResult = await loadPresets({ config: normalizedResult.config });
+
+    const modelsWithPresetIds = extendModelsWithPresetsIds({
+        models: normalizedResult.config.models,
+        presets: presetsResult.presets
+    });
+
+    const configWithPresets = {
+        ...normalizedResult.config,
+        models: modelsWithPresetIds,
+        presets: presetsResult.presets
     };
-}
 
-export async function extendConfig({
-    config,
-    externalModels
-}: {
-    config: RawConfigWithPaths;
-    externalModels?: Model[];
-}): Promise<{
-    valid: boolean;
-    config: Config;
-    errors: (ConfigValidationError | ConfigPresetsError)[];
-}> {
-    const normalizedResult = validateAndNormalizeConfig(config, externalModels);
-    const presetsResult = await 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]
     };
 }
 
-export function validateAndNormalizeConfig(config: RawConfigWithPaths, externalModels?: Model[]): NormalizedValidationResult {
-    // 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 } = extendModelMap(config.models);
-    const extendedConfig: RawConfigWithPaths = {
+export async function loadAndMergeModelsFromFiles(config: Config): Promise<{ config: Config; errors: (ConfigLoadError | ConfigValidationError)[] }> {
+    const { models: modelsFromFiles, errors: fileModelsErrors } = await loadYamlModelsFromFiles(config);
+    const { models: mergedModels, errors: mergeModelErrors } = mergeConfigModelsWithModelsFromFiles(config.models, modelsFromFiles);
+
+    const extendedConfig: Config = {
         ...config,
-        models: extendedModels
+        models: mergedModels
     };
 
-    const { config: mergedConfig, errors: externalModelsMergeErrors } = mergeConfigWithExternalModels(extendedConfig, externalModels);
+    return {
+        config: extendedConfig,
+        errors: [...fileModelsErrors, ...mergeModelErrors]
+    };
+}
 
+export function validateAndNormalizeConfig(config: Config): ConfigValidationResult {
     // 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 } = validateConfig(normalizedConfig);
+    const { config: validatedConfig, errors: validationErrors } = validateConfig(configWithNormalizedModels);
 
-    const errors = [...extendModelErrors, ...externalModelsMergeErrors, ...contentModelsErrors, ...validationErrors];
+    const errors = [...contentModelsErrors, ...validationErrors];
 
     return normalizeValidationResult({
         valid: _.isEmpty(errors),
-        value: validatedConfig,
+        config: validatedConfig,
         errors: errors
     });
 }
 
+export type RawConfigLoaderResult =
+    | {
+          config: RawConfigWithPaths;
+          error: null;
+      }
+    | {
+          config: null;
+          error: ConfigLoadError;
+      };
+
 export async function loadConfigFromDir({
     dirPath,
     stackbitConfigESBuildOutDir,
@@ -189,36 +288,46 @@ export async function loadConfigFromDir({
 }: {
     dirPath: string;
     stackbitConfigESBuildOutDir?: string;
-    watchCallback?: (rawConfigResult: RawConfigLoaderResult) => void;
+    watchCallback?: (result: RawConfigLoaderResult) => void;
     logger?: Logger;
-}): Promise<RawConfigLoaderResultWithStop> {
+}): Promise<RawConfigLoaderResult & StopConfigWatch> {
+    function wrapResult(result: LoadRawConfigResult, configFilePath: string): RawConfigLoaderResult {
+        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 getFirstExistingFile(STACKBIT_CONFIG_YAML_FILES, dirPath);
         if (stackbitYamlPath) {
-            const { config, errors } = await loadConfigWithModelsFromDir(dirPath);
+            logger?.debug(`loading Stackbit configuration from ${stackbitYamlPath}`);
+            const result = await loadStackbitYamlFromDir(dirPath);
             let close: () => Promise<void> = async () => void 0;
             let reload: () => void = () => void 0;
             let stopped = false;
 
             if (watchCallback) {
-                const watcher = chokidar.watch([...STACKBIT_CONFIG_YAML_FILES, '.stackbit'], {
+                const watcher = chokidar.watch([...STACKBIT_CONFIG_YAML_FILES], {
                     cwd: dirPath,
                     persistent: true,
                     ignoreInitial: true
                 });
                 const throttledFileChange = _.throttle(async () => {
-                    const { config, errors } = await loadConfigWithModelsFromDir(dirPath);
-                    watchCallback({
-                        config: config
-                            ? {
-                                  ...config,
-                                  dirPath: dirPath,
-                                  filePath: stackbitYamlPath
-                              }
-                            : undefined,
-                        errors
-                    });
+                    const result = await loadStackbitYamlFromDir(dirPath);
+                    watchCallback(wrapResult(result, stackbitYamlPath));
                 }, 1000);
                 const handleFileChange = (path: string) => {
                     logger?.debug(`identified change in stackbit config file: ${path}, reloading config...`);
@@ -231,7 +340,8 @@ export async function loadConfigFromDir({
                 watcher.on('unlinkDir', handleFileChange);
                 watcher.on('error', (error) => {
                     watchCallback({
-                        errors: [new ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })]
+                        config: null,
+                        error: new ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })
                     });
                 });
                 close = async () => {
@@ -248,45 +358,23 @@ export async function loadConfigFromDir({
             }
 
             return {
-                config: config
-                    ? {
-                          ...config,
-                          dirPath: dirPath,
-                          filePath: stackbitYamlPath
-                      }
-                    : undefined,
+                ...wrapResult(result, stackbitYamlPath),
                 stop: close,
-                reload: reload,
-                errors: errors
+                reload: reload
             };
         }
     } catch (error: any) {
         return {
-            errors: [new ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })]
+            config: null,
+            error: new ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })
         };
     }
 
-    function wrapResult(result: LoadRawConfigResult, configFilePath: string): RawConfigLoaderResult {
-        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 getFirstExistingFile(STACKBIT_CONFIG_JS_FILES, dirPath);
         if (configFilePath) {
+            logger?.debug(`loading Stackbit configuration from: ${configFilePath}`);
             const configResult = await loadStackbitConfigFromJs({
                 configPath: configFilePath,
                 outDir: stackbitConfigESBuildOutDir ?? '.stackbit/cache',
@@ -302,17 +390,19 @@ export async function loadConfigFromDir({
         }
     } catch (error: any) {
         return {
-            errors: [new ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })]
+            config: null,
+            error: new ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })
         };
     }
 
     return {
-        errors: [new ConfigLoadError(STACKBIT_CONFIG_NOT_FOUND)]
+        config: null,
+        error: new ConfigLoadError(STACKBIT_CONFIG_NOT_FOUND)
     };
 }
 
 async function loadModelsFromExternalSource(
-    config: RawConfigWithPaths,
+    config: Config,
     dirPath: string,
     modelsSource?: ModelsSource
 ): Promise<{ models: Model[]; errors: ConfigLoadError[] }> {
@@ -378,201 +468,225 @@ async function loadConfigFromDotStackbit(dirPath: string) {
     return _.isEmpty(config) ? null : config;
 }
 
-function mergeConfigWithExternalModels(config: RawConfigWithPaths, externalModels?: Model[]): { config: RawConfigWithPaths; errors: ConfigValidationError[] } {
-    if (!externalModels || externalModels.length === 0) {
-        return {
-            config,
-            errors: []
-        };
+export function mergeConfigModelsWithExternalModels({ configModels, externalModels }: { configModels: Model[]; externalModels: Model[] }): Model[] {
+    if (externalModels.length === 0) {
+        return configModels;
+    }
+    if (configModels.length === 0) {
+        return externalModels;
     }
 
-    const stackbitModels = config?.models ?? {};
-    const errors: ConfigValidationError[] = [];
+    const mergedModelsByName: Record<string, Model> = _.keyBy(externalModels, 'name');
 
-    const models = _.reduce(
-        externalModels,
-        (modelMap: Record<string, YamlModel>, externalModel) => {
-            const { name, ...rest } = externalModel;
-            return Object.assign(modelMap, { [name]: rest });
-        },
-        {}
-    );
-
-    _.forEach(stackbitModels, (stackbitModel: any, modelName: any) => {
-        let externalModel = models[modelName];
+    for (const configModel of configModels) {
+        const externalModel = mergedModelsByName[configModel.name];
         if (!externalModel) {
-            return;
+            continue;
         }
 
-        const modelType = stackbitModel.type ? (stackbitModel.type === 'config' ? 'data' : stackbitModel.type) : externalModel.type ?? 'object';
-        const urlPath = modelType === 'page' ? stackbitModel?.urlPath ?? '/{slug}' : null;
+        const modelType = configModel.type ? (configModel.type === 'config' ? 'data' : configModel.type) : externalModel.type ?? 'object';
 
-        externalModel = Object.assign(
+        let mergedModel: Model = Object.assign(
             {},
             externalModel,
-            _.pick(stackbitModel, ['__metadata', 'label', 'description', 'thumbnail', 'singleInstance', 'readOnly', 'labelField', 'fieldGroups']),
-            omitByNil({
-                type: modelType,
-                urlPath
-            })
+            _.pick(configModel, ['__metadata', 'urlPath', 'label', 'description', 'thumbnail', 'singleInstance', 'readOnly', 'labelField', 'fieldGroups']),
+            { type: modelType }
         );
 
-        externalModel = mapModelFieldsRecursively(externalModel as Model, (externalField, modelKeyPath) => {
-            const stackbitField = getModelFieldForModelKeyPath(stackbitModel, modelKeyPath);
-            if (!stackbitField) {
-                return externalField;
-            }
+        if (mergedModel.type === 'page' && !mergedModel.urlPath) {
+            mergedModel.urlPath = '/{slug}';
+        }
 
-            let override = {};
-            if (externalField.type === 'json' && stackbitField.type === 'style') {
-                override = stackbitField;
-            } else if (externalField.type === 'string' && stackbitField.type === 'color') {
-                override = { type: 'color' };
-            } else if (externalField.type === 'enum') {
-                override = _.pick(stackbitField, ['options']);
-            } else if (externalField.type === 'number') {
-                override = _.pick(stackbitField, ['subtype', 'min', 'max', 'step', 'unit']);
-            } else if (externalField.type === 'object') {
-                override = _.pick(stackbitField, ['labelField', 'thumbnail', 'fieldGroups']);
+        mergedModel = mapModelFieldsRecursively(
+            mergedModel,
+            (externalField, modelKeyPath): Field => {
+                const stackbitField = getModelFieldForModelKeyPath(configModel, modelKeyPath);
+                if (!stackbitField) {
+                    return externalField;
+                }
+
+                let override = {};
+                if (externalField.type === 'json' && stackbitField.type === 'style') {
+                    override = stackbitField;
+                } else if (externalField.type === 'string' && stackbitField.type === 'color') {
+                    override = { type: 'color' };
+                } else if (externalField.type === 'enum') {
+                    override = _.pick(stackbitField, ['options']);
+                } else if (externalField.type === 'number') {
+                    override = _.pick(stackbitField, ['subtype', 'min', 'max', 'step', 'unit']);
+                } else if (externalField.type === 'object') {
+                    override = _.pick(stackbitField, ['labelField', 'thumbnail', 'fieldGroups']);
+                } else if (externalField.type === 'reference' || externalField.type === 'model') {
+                    override = _.pick(stackbitField, ['models']);
+                }
+
+                return Object.assign(
+                    {},
+                    externalField,
+                    _.pick(stackbitField, ['label', 'description', 'required', 'default', 'group', 'const', 'hidden', 'readOnly', 'controlType']),
+                    override
+                );
             }
+        );
 
-            return Object.assign(
-                {},
-                externalField,
-                _.pick(stackbitField, ['label', 'description', 'required', 'default', 'group', 'const', 'hidden', 'readOnly', 'controlType']),
-                override
-            );
-        }) as YamlModel;
+        mergedModelsByName[configModel.name] = mergedModel;
+    }
 
-        models[modelName] = externalModel;
-    });
+    return Object.values(mergedModelsByName);
+}
+
+function normalizeConfig(rawConfig: RawConfigWithPaths): Config {
+    const stackbitVersion = String(_.get(rawConfig, 'stackbitVersion', LATEST_STACKBIT_VERSION));
+    const ver = semver.coerce(stackbitVersion);
+    const isGTEStackbitYamlV5 = ver ? semver.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 = _.reduce(modelMap, (accum: Model[], 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 || _.get(rawConfig, 'customContentReload', _.get(rawConfig, 'hcrHandled', !isGTEStackbitYamlV5)),
+        internalStackbitRunnerOptions: getInternalStackbitRunnerOptions(rawConfig)
     };
 }
 
-function normalizeConfig(config: any): any {
-    const pageLayoutKey = _.get(config, 'pageLayoutKey', 'layout');
-    const objectTypeKey = _.get(config, 'objectTypeKey', 'type');
-    const stackbitYamlVersion = String(_.get(config, 'stackbitVersion', ''));
+function normalizeModels(config: Config): Config {
+    const pageLayoutKey = config.pageLayoutKey ?? 'layout';
+    const objectTypeKey = config.objectTypeKey ?? 'type';
+    const stackbitYamlVersion = String(config.stackbitVersion ?? '');
     const ver = semver.coerce(stackbitYamlVersion);
     const isStackbitYamlV2 = ver ? semver.satisfies(ver, '<0.3.0') : false;
-    const isStackbitYamlV5 = ver ? semver.satisfies(ver, '>=0.5.0') : false;
-    const models = config?.models || {};
+    const models = config.models;
+    const modelsByName = _.keyBy(models, 'name');
     const gitCMS = isGitCMS(config);
 
-    rename(config, 'logicFields', 'noEncodeFields');
-    config.hcrHandled = !stackbitYamlVersion || _.get(config, 'customContentReload', _.get(config, 'hcrHandled', !isStackbitYamlV5));
-    config.internalStackbitRunnerOptions = getInternalStackbitRunnerOptions(config);
-
-    _.forEach(models, (model, modelName) => {
-        if (!model) {
-            return;
-        }
-
-        if (!_.has(model, 'type')) {
-            model.type = 'object';
-        }
-
-        // add model label if not set
-        if (!_.has(model, 'label')) {
-            model.label = _.startCase(modelName);
-        }
+    const mappedModels = models.map(
+        (model): Model => {
+            // create shallow copy of the model to prevent mutation of original models
+            model = { ...model };
 
-        if (_.has(model, 'fields') && !Array.isArray(model.fields)) {
-            model.fields = [];
-        }
-
-        if (isPageModel(model)) {
-            // rename old 'template' property to 'layout'
-            rename(model, 'template', 'layout');
+            if (!_.has(model, 'type')) {
+                model.type = 'object';
+            }
 
-            updatePageUrlPath(model);
+            // add model label if not set
+            if (!_.has(model, 'label')) {
+                model.label = _.startCase(model.name);
+            }
 
-            if (gitCMS) {
-                updatePageFilePath(model, config);
-                addMarkdownContentField(model);
+            if (_.has(model, 'fields') && !Array.isArray(model.fields)) {
+                model.fields = [];
             }
-        } else if (isDataModel(model) && gitCMS) {
-            updateDataFilePath(model, config);
-        }
 
-        if (gitCMS) {
-            // TODO: do not add pageLayoutKey and objectTypeKey fields to models,
-            //  The content validator should always assume these fields.
-            //  And when new objects created from UI, it should add these fields automatically.
             if (isPageModel(model)) {
-                addLayoutFieldToPageModel(model, pageLayoutKey, modelName);
-            } else if (isDataModel(model) && !isListDataModel(model)) {
-                addObjectTypeKeyField(model, objectTypeKey, modelName);
-            }
-        }
+                // rename old 'template' property to 'layout'
+                rename(model, 'template', 'layout');
 
-        if (isListDataModel(model)) {
-            // 'items.type' of list model defaults to 'string', set it explicitly
-            if (!_.has(model, 'items.type')) {
-                _.set(model, 'items.type', 'string');
-            }
-            if (isObjectListItems(model.items)) {
-                assignLabelFieldIfNeeded(model.items);
-            }
-        } else if (!_.has(model, 'labelField')) {
-            assignLabelFieldIfNeeded(model);
-        }
+                updatePageUrlPath(model);
 
-        iterateModelFieldsRecursively(model, (field: any) => {
-            // add field label if label is not set
-            if (!_.has(field, 'label')) {
-                field.label = _.startCase(field.name);
+                if (gitCMS) {
+                    updatePageFilePath(model, config);
+                    addMarkdownContentField(model);
+                }
+            } else if (isDataModel(model) && gitCMS) {
+                updateDataFilePath(model, config);
             }
 
-            if (isListField(field)) {
-                field = normalizeListFieldInPlace(field);
-                field = field.items;
+            if (gitCMS) {
+                // TODO: do not add pageLayoutKey and objectTypeKey fields to models,
+                //  The content validator should always assume these fields.
+                //  And when new objects created from UI, it should add these fields automatically.
+                if (isPageModel(model)) {
+                    addLayoutFieldToPageModel(model, pageLayoutKey, model.name);
+                } else if (isDataModel(model) && !isListDataModel(model)) {
+                    addObjectTypeKeyField(model, objectTypeKey, model.name);
+                }
             }
 
-            if (isObjectField(field)) {
-                assignLabelFieldIfNeeded(field);
-            } else if (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 = _.get(field, 'models', []);
-            } else if (field.type === 'model' && _.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 (isListDataModel(model)) {
+                // 'items.type' of list model defaults to 'string', set it explicitly
+                normalizeListFieldInPlace(model);
+                if (isObjectListItems(model.items)) {
+                    assignLabelFieldIfNeeded(model.items);
+                }
+            } else if (!_.has(model, 'labelField')) {
+                assignLabelFieldIfNeeded(model);
             }
 
-            if (isStackbitYamlV2) {
-                // in stackbit.yaml v0.2.x, the 'reference' field was what we have today as 'model' field:
-                if (isReferenceField(field)) {
-                    field = (field as unknown) as FieldModel;
-                    field.type = 'model';
-                    field.models = _.get(field, 'models', []);
+            return mapModelFieldsRecursively(
+                model,
+                (field: Field): Field => {
+                    // create shallow copy of the field to prevent mutation of original field
+                    field = { ...field };
+
+                    // add field label if label is not set
+                    if (!_.has(field, 'label')) {
+                        field.label = _.startCase(field.name);
+                    }
+
+                    return mapListItemsPropsOrSelfSpecificProps(field, (fieldSpecificProps) => {
+                        if (isObjectField(fieldSpecificProps)) {
+                            assignLabelFieldIfNeeded(fieldSpecificProps);
+                        } else if (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 as any).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: _.get(fieldSpecificProps, 'models', [])
+                            };
+                        } else if (fieldSpecificProps.type === 'model' && _.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 as any;
+                            fieldSpecificProps = {
+                                ...rest,
+                                models: [model]
+                            };
+                        }
+
+                        if (isStackbitYamlV2) {
+                            // in stackbit.yaml v0.2.x, the 'reference' field was what we have today as 'model' field:
+                            if (isReferenceField(fieldSpecificProps)) {
+                                fieldSpecificProps = {
+                                    ...fieldSpecificProps,
+                                    type: 'model',
+                                    models: _.get(fieldSpecificProps, 'models', [])
+                                };
+                            }
+                        }
+
+                        return fieldSpecificProps;
+                    });
                 }
-            }
-        });
-    });
+            );
+        }
+    );
 
-    return config;
+    return {
+        ...config,
+        models: mappedModels
+    };
 }
 
-function updatePageUrlPath(model: YamlPageModel) {
+function updatePageUrlPath(model: PageModel) {
     // set default urlPath if not set
     if (!model.urlPath) {
         model.urlPath = '/{slug}';
@@ -585,7 +699,7 @@ function updatePageUrlPath(model: YamlPageModel) {
  * If the model has no `filePath` property, then `filePath` is naively inferred by
  * prefixing `urlPath` with `pagesDir` and appending the `.md` extension.
  */
-function updatePageFilePath(model: YamlPageModel, config: Config) {
+function updatePageFilePath(model: PageModel, config: Config) {
     let filePath;
     if (model.filePath) {
         filePath = model.filePath;
@@ -605,7 +719,7 @@ function updatePageFilePath(model: YamlPageModel, config: Config) {
     model.filePath = path.join(parentDir, filePath);
 }
 
-function updateDataFilePath(model: YamlDataModel, config: Config) {
+function updateDataFilePath(model: DataModel, config: Config) {
     let filePath;
     if (model.filePath) {
         filePath = model.filePath;
@@ -619,7 +733,7 @@ function updateDataFilePath(model: YamlDataModel, config: Config) {
     model.filePath = path.join(parentDir, filePath);
 }
 
-function addMarkdownContentField(model: YamlPageModel) {
+function addMarkdownContentField(model: PageModel) {
     if (model.hideContent) {
         return;
     }
@@ -635,7 +749,7 @@ function addMarkdownContentField(model: YamlPageModel) {
     });
 }
 
-function addLayoutFieldToPageModel(model: any, pageLayoutKey: any, modelName: string) {
+function addLayoutFieldToPageModel(model: PageModel, pageLayoutKey: string, modelName: string) {
     if (_.intersection(_.keys(model), ['file', 'folder', 'match', 'exclude']).length === 0 && !_.get(model, 'layout')) {
         model.layout = modelName;
     }
@@ -656,7 +770,7 @@ function addLayoutFieldToPageModel(model: any, pageLayoutKey: any, modelName: st
     });
 }
 
-function addObjectTypeKeyField(model: any, objectTypeKey: string, modelName: string) {
+function addObjectTypeKeyField(model: DataModelSingle, objectTypeKey: string, modelName: string) {
     const hasObjectTypeField = _.find(_.get(model, 'fields'), { name: objectTypeKey });
     if (hasObjectTypeField) {
         return;
@@ -673,40 +787,42 @@ function addObjectTypeKeyField(model: any, objectTypeKey: string, modelName: str
 
 /**
  * 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: any) {
-    if (isListField(field)) {
-        field = getListFieldItems(field);
-    }
+function getReferencedModelNames(field: Field) {
+    const fieldSpecificProps = 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: string[] = [];
-    if (isModelField(field) && field.models?.length > 1) {
-        const modelNames = field.models;
+    if (isModelField(fieldSpecificProps) && fieldSpecificProps.models?.length > 1) {
+        const modelNames = fieldSpecificProps.models;
         referencedModelNames = _.union(referencedModelNames, modelNames);
-    } else if (isReferenceField(field) && field.models?.length > 0) {
-        const modelNames = field.models;
+    } else if (isReferenceField(fieldSpecificProps) && fieldSpecificProps.models?.length > 0) {
+        const modelNames = fieldSpecificProps.models;
         referencedModelNames = _.union(referencedModelNames, modelNames);
     }
     return referencedModelNames;
 }
 
-function validateAndExtendContentModels(config: RawConfigWithPaths): ConfigValidationResult {
+function validateAndExtendContentModels(
+    config: Config
+): {
+    config: Config;
+    errors: ConfigValidationError[];
+} {
     const contentModels = config.contentModels ?? {};
-    const models = config.models ?? {};
+    const models = config.models ?? [];
 
+    // external models already merged in mergeConfigModelsWithExternalModels function
     const externalModels = !isGitCMS(config);
     const emptyContentModels = _.isEmpty(contentModels);
 
     if (externalModels || emptyContentModels) {
         return {
-            valid: true,
-            value: config,
+            config: config,
             errors: []
         };
     }
@@ -715,36 +831,36 @@ function validateAndExtendContentModels(config: RawConfigWithPaths): ConfigValid
 
     if (_.isEmpty(models)) {
         return {
-            valid: validationResult.valid,
-            value: config,
+            config: config,
             errors: validationResult.errors
         };
     }
 
-    const extendedModels: YamlModelMap = _.mapValues(
-        models,
-        (model, modelName): YamlModel => {
-            const contentModel = validationResult.value.contentModels![modelName];
+    const extendedModels = models.map(
+        (model): Model => {
+            const contentModel = validationResult.contentModels![model.name];
             if (!contentModel) {
                 return model;
             }
             if (_.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 } : {}),
-                    ..._.omit(contentModel, ['isPage', 'newFilePath']),
-                    ..._.omit(model, 'type')
-                } as YamlModel;
-            } else if (!contentModel.isPage && (!model.type || ['object', 'data'].includes(model.type))) {
+                    ...(newFilePath ? { filePath: newFilePath } : {}),
+                    ...restContentModel,
+                    ...restModel
+                };
+            } else if (!isPage && (!type || ['object', 'data'].includes(type))) {
                 return {
                     type: 'data',
-                    ...(contentModel.newFilePath ? { filePath: contentModel.newFilePath } : {}),
-                    ..._.omit(contentModel, ['isPage', 'newFilePath']),
-                    ..._.omit(model, 'type')
-                } as YamlModel;
+                    ...(newFilePath ? { filePath: newFilePath } : {}),
+                    ...restContentModel,
+                    ...restModel
+                };
             } else {
                 return model;
             }
@@ -752,8 +868,7 @@ function validateAndExtendContentModels(config: RawConfigWithPaths): ConfigValid
     );
 
     return {
-        valid: validationResult.valid,
-        value: {
+        config: {
             ...config,
             models: extendedModels
         },
@@ -761,17 +876,16 @@ function validateAndExtendContentModels(config: RawConfigWithPaths): ConfigValid
     };
 }
 
-function normalizeValidationResult(validationResult: ConfigValidationResult): NormalizedValidationResult {
+function normalizeValidationResult(validationResult: ConfigValidationResult): ConfigValidationResult {
     validationResult = filterAndOrderConfigFields(validationResult);
-    convertModelGroupsToModelList(validationResult);
-    return convertModelsToArray(validationResult);
+    return convertModelGroupsToModelListInPlace(validationResult);
 }
 
 function filterAndOrderConfigFields(validationResult: ConfigValidationResult): ConfigValidationResult {
     // TODO: check if we can move filtering and sorting to Joi
     return {
         ...validationResult,
-        value: _.pick(validationResult.value, [
+        config: _.pick(validationResult.config, [
             'stackbitVersion',
             'ssgName',
             'ssgVersion',
@@ -814,7 +928,7 @@ function filterAndOrderConfigFields(validationResult: ConfigValidationResult): C
             'encodedFieldTypes', // obsolete, left for backward compatibility
             'noEncodeFields', // obsolete, left for backward compatibility
             'omitFields' // obsolete, left for backward compatibility
-        ]) as RawConfigWithPaths
+        ]) as Config
     };
 }
 
@@ -822,18 +936,18 @@ function filterAndOrderConfigFields(validationResult: ConfigValidationResult): C
  * Collects models groups and injects them into the `models` array of the
  * `reference` and `model` field types
  */
-function convertModelGroupsToModelList(validationResult: ConfigValidationResult) {
-    const models = validationResult.value?.models ?? {};
+function convertModelGroupsToModelListInPlace(validationResult: ConfigValidationResult): ConfigValidationResult {
+    const models = validationResult.config?.models ?? [];
 
     const groupMap = _.reduce(
         models,
-        (groupMap, model, modelName) => {
+        (groupMap, model) => {
             if (!model.groups) {
                 return groupMap;
             }
             const key = model?.type === 'object' ? 'objectModels' : 'documentModels';
             _.forEach(model.groups, (groupName) => {
-                append(groupMap, [groupName, key], modelName);
+                append(groupMap, [groupName, key], model.name);
             });
             delete model.groups;
             return groupMap;
@@ -848,92 +962,41 @@ function convertModelGroupsToModelList(validationResult: ConfigValidationResult)
         });
     });
 
-    _.forEach(models, (model) => {
-        iterateModelFieldsRecursively(model, (field: any) => {
-            if (isListField(field)) {
-                field = field.items;
-            }
-            if (field.groups) {
-                let key: string | null = null;
-                if (isModelField(field)) {
-                    key = 'objectModels';
-                } else if (isReferenceField(field)) {
-                    key = 'documentModels';
-                }
-                if (key) {
-                    field.models = _.reduce(
-                        field.groups,
+    const mappedModels = models.map((model) => {
+        return mapModelFieldsRecursively(
+            model,
+            (field): Field => {
+                return mapListItemsPropsOrSelfSpecificProps(field, (fieldSpecificProps) => {
+                    if (!isModelField(fieldSpecificProps) && !isReferenceField(fieldSpecificProps)) {
+                        return fieldSpecificProps;
+                    }
+                    const { ...cloned } = fieldSpecificProps;
+                    const key = isModelField(fieldSpecificProps) ? 'objectModels' : 'documentModels';
+                    const modelNames = _.reduce(
+                        cloned.groups,
                         (modelNames, groupName) => {
                             const objectModelNames = _.get(groupMap, [groupName, key], []);
                             return _.uniq(modelNames.concat(objectModelNames));
                         },
-                        field.models || []
+                        fieldSpecificProps.models || []
                     );
-                }
-                delete field.groups;
+                    delete cloned.groups;
+                    return Object.assign(cloned, { models: modelNames });
+                });
             }
-        });
-    });
-}
-
-function convertModelsToArray(validationResult: ConfigValidationResult): NormalizedValidationResult {
-    const config = validationResult.value;
-    const { stackbitVersion = 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 ?? {};
-    const modelArray: Model[] = (_.map(
-        modelMap,
-        (yamlModel: YamlModel, modelName: string): Model => {
-            return {
-                name: modelName,
-                ...yamlModel
-            };
-        }
-    ) as unknown) as Model[];
-
-    if (!isGitCMS(config)) {
-        addImageModel(modelArray);
-    }
-
-    const convertedErrors = _.map(validationResult.errors, (error: ConfigValidationError) => {
-        if (error.fieldPath[0] === 'models' && typeof error.fieldPath[1] == 'string') {
-            const modelName = error.fieldPath[1];
-            const modelIndex = _.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: Model[]) {
-    models.push({
-        type: 'image',
-        name: '__image_model',
-        label: 'Image',
-        labelField: 'title',
-        fields: [
-            { name: 'title', type: 'string' },
-            { name: 'url', type: 'string' }
-        ]
-    });
-}
-
-function isGitCMS(config: RawConfigWithPaths) {
+function isGitCMS(config: Config) {
     return !config.contentSources && (!config.cmsName || config.cmsName === 'git');
 }