@stackbit/sdk 0.2.39 → 0.3.0

package/src/config/config-loader.ts

@@ -1,45 +1,51 @@
 import path from 'path';
 import fse from 'fs-extra';
-import yaml from 'js-yaml';
+import chokidar from 'chokidar';
 import semver from 'semver';
 import _ from 'lodash';
 
+import { append, getFirstExistingFile, omitByNil, prepend, rename } from '@stackbit/utils';
+
 import { ConfigValidationResult, validateConfig, validateContentModels } from './config-validator';
-import {
-    ConfigError,
-    ConfigLoadError,
-    ConfigPresetsError,
-    ConfigValidationError
-} from './config-errors';
-import { loadStackbitConfigFromJs, LoadStackbitConfigResult, StopConfigWatch } from './config-loader-esbuild';
+import { ConfigError, ConfigLoadError, ConfigPresetsError, ConfigValidationError, STACKBIT_CONFIG_NOT_FOUND } from './config-errors';
+import { loadStackbitConfigFromJs } from './config-loader-esbuild';
 import {
     assignLabelFieldIfNeeded,
     extendModelMap,
     getListFieldItems,
+    getModelFieldForModelKeyPath,
     isCustomModelField,
-    isEnumField,
+    isDataModel,
     isListDataModel,
     isListField,
     isModelField,
     isObjectField,
     isObjectListItems,
     isPageModel,
-    isDataModel,
     isReferenceField,
     iterateModelFieldsRecursively,
     mapModelFieldsRecursively,
     normalizeListFieldInPlace,
-    getModelFieldForModelKeyPath
+    Logger
 } from '../utils';
-import { append, prepend, omitByNil, parseFile, readDirRecursively, reducePromise, rename, getFirstExistingFile } from '@stackbit/utils';
-import { Config, DataModel, FieldEnum, FieldModel, FieldObjectProps, Model, ModelsSource, PageModel, YamlModel } from './config-types';
+import { Config, DataModel, FieldModel, Model, ModelMap, ModelsSource, PageModel, YamlModel } from './config-types';
 import { loadPresets } from './presets-loader';
+import {
+    LoadRawConfigResult,
+    StopConfigWatch,
+    RawConfigWithPaths,
+    LATEST_STACKBIT_VERSION,
+    STACKBIT_CONFIG_JS_FILES,
+    STACKBIT_CONFIG_YAML_FILES,
+    loadConfigWithModelsFromDir
+} from './config-loader-utils';
 
 export interface ConfigLoaderOptions {
     dirPath: string;
     modelsSource?: ModelsSource;
     stackbitConfigESBuildOutDir?: string;
     watchCallback?: (result: ConfigLoaderResult) => void;
+    logger?: Logger;
 }
 
 export interface ConfigLoaderResult {
@@ -48,6 +54,8 @@ export interface ConfigLoaderResult {
     errors: ConfigError[];
 }
 
+export type ConfigLoaderResultWithStop = ConfigLoaderResult & StopConfigWatch;
+
 export interface NormalizedValidationResult {
     valid: boolean;
     config: Config;
@@ -55,29 +63,39 @@ export interface NormalizedValidationResult {
 }
 
 export interface RawConfigLoaderResult {
-    config?: Record<string, any>;
+    config?: RawConfigWithPaths;
     errors: ConfigLoadError[];
 }
 
+export type RawConfigLoaderResultWithStop = RawConfigLoaderResult & StopConfigWatch;
+
 export async function loadConfig({
     dirPath,
     modelsSource,
     stackbitConfigESBuildOutDir,
-    watchCallback
-}: ConfigLoaderOptions): Promise<ConfigLoaderResult & StopConfigWatch> {
+    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);
+        };
+    }
+
     const rawConfigResult = await loadConfigFromDir({
         dirPath,
         stackbitConfigESBuildOutDir,
-        watchCallback: watchCallback
-            ? async (rawConfigResult: RawConfigLoaderResult) => {
-                  const configLoaderResult = await processConfigLoaderResult({ rawConfigResult, dirPath, modelsSource });
-                  watchCallback(configLoaderResult);
-              }
-            : undefined
+        watchCallback: wrappedCallback,
+        logger
     });
 
     const configLoaderResult = await processConfigLoaderResult({ rawConfigResult, dirPath, modelsSource });
-    return Object.assign(configLoaderResult, { stop: rawConfigResult.stop });
+    return Object.assign(configLoaderResult, {
+        stop: rawConfigResult.stop,
+        reload: rawConfigResult.reload
+    });
 }
 
 async function processConfigLoaderResult({
@@ -101,7 +119,7 @@ async function processConfigLoaderResult({
 
     const { models: externalModels, errors: externalModelsLoadErrors } = await loadModelsFromExternalSource(config, dirPath, modelsSource);
 
-    const extendedConfig = await extendConfig({ dirPath, config, externalModels });
+    const extendedConfig = await extendConfig({ config, externalModels });
 
     return {
         valid: extendedConfig.valid,
@@ -111,12 +129,10 @@ async function processConfigLoaderResult({
 }
 
 export async function extendConfig({
-    dirPath,
     config,
     externalModels
 }: {
-    dirPath: string;
-    config: Record<string, any>;
+    config: RawConfigWithPaths;
     externalModels?: Model[];
 }): Promise<{
     valid: boolean;
@@ -124,7 +140,7 @@ export async function extendConfig({
     errors: (ConfigValidationError | ConfigPresetsError)[];
 }> {
     const normalizedResult = validateAndNormalizeConfig(config, externalModels);
-    const presetsResult = await loadPresets(dirPath, normalizedResult.config);
+    const presetsResult = await loadPresets(config.dirPath, normalizedResult.config);
     return {
         valid: normalizedResult.valid,
         config: presetsResult.config,
@@ -132,12 +148,12 @@ export async function extendConfig({
     };
 }
 
-export function validateAndNormalizeConfig(config: Record<string, any>, externalModels?: Model[]): NormalizedValidationResult {
+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 as any);
-    const extendedConfig = {
+    const { models: extendedModels, errors: extendModelErrors } = extendModelMap(config.models);
+    const extendedConfig: RawConfigWithPaths = {
         ...config,
         models: extendedModels
     };
@@ -167,32 +183,80 @@ export function validateAndNormalizeConfig(config: Record<string, any>, external
 export async function loadConfigFromDir({
     dirPath,
     stackbitConfigESBuildOutDir,
-    watchCallback
+    watchCallback,
+    logger
 }: {
     dirPath: string;
     stackbitConfigESBuildOutDir?: string;
     watchCallback?: (rawConfigResult: RawConfigLoaderResult) => void;
-}): Promise<RawConfigLoaderResult & StopConfigWatch> {
+    logger?: Logger
+}): Promise<RawConfigLoaderResultWithStop> {
     // try to load stackbit config from YAML files
     try {
-        const stackbitYamlPath = path.join(dirPath, 'stackbit.yaml');
-        const stackbitYamlExists = await fse.pathExists(stackbitYamlPath);
-        if (stackbitYamlExists) {
-            const stackbitYamlResult = await loadConfigFromStackbitYaml(stackbitYamlPath);
-            if (stackbitYamlResult.error) {
-                return { errors: [stackbitYamlResult.error] };
+        const stackbitYamlPath = await getFirstExistingFile(STACKBIT_CONFIG_YAML_FILES, dirPath);
+        if (stackbitYamlPath) {
+            const { config, errors } = await loadConfigWithModelsFromDir(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'], {
+                    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
+                    });
+                }, 1000);
+                const handleFileChange = (path: string) => {
+                    logger?.debug(`identified change in stackbit config file: ${path}, reloading config...`);
+                    throttledFileChange();
+                };
+                watcher.on('add', handleFileChange);
+                watcher.on('change', handleFileChange);
+                watcher.on('unlink', handleFileChange);
+                watcher.on('addDir', handleFileChange);
+                watcher.on('unlinkDir', handleFileChange);
+                watcher.on('error', (error) => {
+                    watchCallback({
+                        errors: [new ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })]
+                    });
+                });
+                close = async () => {
+                    if (stopped) {
+                        return;
+                    }
+                    stopped = true;
+                    throttledFileChange.cancel();
+                    watcher.close();
+                };
+                reload = () => {
+                    throttledFileChange();
+                };
             }
 
-            const { models: modelsFromFiles, errors: fileModelsErrors } = await loadModelsFromFiles(dirPath, stackbitYamlResult.config);
-
-            const mergedModels = mergeConfigModelsWithModelsFromFiles(stackbitYamlResult.config.models ?? {}, modelsFromFiles);
-
             return {
-                config: {
-                    ...stackbitYamlResult.config,
-                    models: mergedModels
-                },
-                errors: fileModelsErrors
+                config: config
+                    ? {
+                          ...config,
+                          dirPath: dirPath,
+                          filePath: stackbitYamlPath
+                      }
+                    : undefined,
+                stop: close,
+                reload: reload,
+                errors: errors
             };
         }
     } catch (error: any) {
@@ -201,14 +265,18 @@ export async function loadConfigFromDir({
         };
     }
 
-    function wrapResult(result: LoadStackbitConfigResult) {
+    function wrapResult(result: LoadRawConfigResult, configFilePath: string): RawConfigLoaderResult {
         if (result.error) {
             return {
                 errors: [result.error]
             };
         } else {
             return {
-                config: result.config,
+                config: {
+                    ...result.config,
+                    dirPath: dirPath,
+                    filePath: configFilePath
+                },
                 errors: []
             };
         }
@@ -216,19 +284,20 @@ export async function loadConfigFromDir({
 
     // try to load stackbit config from JavaScript files
     try {
-        const configFilePath = await getFirstExistingFile(['stackbit.config.js', 'stackbit.config.cjs', 'stackbit.config.mjs', 'stackbit.config.ts'], dirPath);
+        const configFilePath = await getFirstExistingFile(STACKBIT_CONFIG_JS_FILES, dirPath);
         if (configFilePath) {
             const configResult = await loadStackbitConfigFromJs({
                 configPath: configFilePath,
-                outDir: stackbitConfigESBuildOutDir,
+                outDir: stackbitConfigESBuildOutDir ?? '.stackbit/cache',
                 watch: !!watchCallback,
+                logger: logger,
                 callback: watchCallback
-                    ? (result: LoadStackbitConfigResult) => {
-                          watchCallback(wrapResult(result));
+                    ? (result: LoadRawConfigResult) => {
+                          watchCallback(wrapResult(result, configFilePath));
                       }
                     : undefined
             });
-            return Object.assign(wrapResult(configResult), { stop: configResult.stop });
+            return Object.assign(wrapResult(configResult, configFilePath), { stop: configResult.stop });
         }
     } catch (error: any) {
         return {
@@ -237,100 +306,19 @@ export async function loadConfigFromDir({
     }
 
     return {
-        errors: [
-            new ConfigLoadError(
-                'stackbit.yaml or stackbit.config.js was not found, please refer Stackbit documentation: https://www.stackbit.com/docs/stackbit-yaml/'
-            )
-        ]
+        errors: [new ConfigLoadError(STACKBIT_CONFIG_NOT_FOUND)]
     };
 }
 
-type StackbitYamlConfigResult = { config: Record<string, any>; error?: never } | { config?: never; error: ConfigLoadError };
-
-async function loadConfigFromStackbitYaml(stackbitYamlPath: string): Promise<StackbitYamlConfigResult> {
-    const stackbitYaml = await fse.readFile(stackbitYamlPath);
-    const config = yaml.load(stackbitYaml.toString('utf8'), { schema: yaml.JSON_SCHEMA });
-    if (!config || typeof config !== 'object') {
-        return {
-            error: new ConfigLoadError('error parsing stackbit.yaml, please refer Stackbit documentation: https://www.stackbit.com/docs/stackbit-yaml/')
-        };
-    }
-    return { config };
-}
-
-async function loadModelsFromFiles(dirPath: string, config: Record<string, any>): Promise<{ models: Record<string, any>; errors: ConfigLoadError[] }> {
-    const modelsSource = _.get(config, 'modelsSource', {});
-    const sourceType = _.get(modelsSource, 'type', 'files');
-    const defaultModelDirs = ['node_modules/@stackbit/components/models', '.stackbit/models'];
-    const modelDirs =
-        sourceType === 'files'
-            ? _.castArray(_.get(modelsSource, 'modelDirs', defaultModelDirs)).map((modelDir: string) => _.trim(modelDir, '/'))
-            : defaultModelDirs;
-
-    const modelFiles = await reducePromise(
-        modelDirs,
-        async (modelFiles: string[], modelDir) => {
-            const absModelsDir = path.join(dirPath, modelDir);
-            const dirExists = await fse.pathExists(absModelsDir);
-            if (!dirExists) {
-                return modelFiles;
-            }
-            const files = await readModelFilesFromDir(absModelsDir);
-            return modelFiles.concat(files.map((filePath) => path.join(modelDir, filePath)));
-        },
-        []
-    );
-
-    return reducePromise(
-        modelFiles,
-        async (result: { models: any; errors: ConfigLoadError[] }, modelFile) => {
-            let model;
-            try {
-                model = await parseFile(path.join(dirPath, modelFile));
-            } catch (error) {
-                return {
-                    models: result.models,
-                    errors: result.errors.concat(new ConfigLoadError(`error parsing model, file: ${modelFile}`))
-                };
-            }
-            const modelName = model?.name;
-            if (!modelName) {
-                return {
-                    models: result.models,
-                    errors: result.errors.concat(new ConfigLoadError(`model does not have a name, file: ${modelFile}`))
-                };
-            }
-            result.models[modelName] = _.omit(model, 'name');
-            result.models[modelName].__metadata = {
-                filePath: modelFile
-            };
-            return result;
-        },
-        { models: {}, errors: [] }
-    );
-}
-
-async function readModelFilesFromDir(modelsDir: string) {
-    return await readDirRecursively(modelsDir, {
-        filter: (filePath, stats) => {
-            if (stats.isDirectory()) {
-                return true;
-            }
-            const extension = path.extname(filePath).substring(1);
-            return stats.isFile() && ['yaml', 'yml'].includes(extension);
-        }
-    });
-}
-
 async function loadModelsFromExternalSource(
-    config: Record<string, any>,
+    config: RawConfigWithPaths,
     dirPath: string,
     modelsSource?: ModelsSource
 ): Promise<{ models: Model[]; errors: ConfigLoadError[] }> {
-    modelsSource = _.assign({}, modelsSource, config.modelSource);
+    modelsSource = _.assign({}, modelsSource, config.modelsSource);
     const sourceType = _.get(modelsSource, 'type', 'files');
     if (sourceType === 'files') {
-        // we already loaded models from files inside loadModelsFromFiles function
+        // we already loaded models from files inside loadConfigFromDir function
         return { models: [], errors: [] };
     } else if (sourceType === 'contentful') {
         const contentfulModule = _.get(modelsSource, 'module', '@stackbit/cms-contentful');
@@ -389,36 +377,7 @@ async function loadConfigFromDotStackbit(dirPath: string) {
     return _.isEmpty(config) ? null : config;
 }
 
-function mergeConfigModelsWithModelsFromFiles(configModels: any, modelsFromFiles: Record<string, any>) {
-    const mergedModels = _.mapValues(modelsFromFiles, (modelFromFile, modelName) => {
-        // resolve thumbnails of models loaded from files
-        const modelFilePath = modelFromFile.__metadata?.filePath;
-        resolveThumbnailPathForModel(modelFromFile, modelFilePath);
-        iterateModelFieldsRecursively(modelFromFile, (field: any) => {
-            if (isListField(field)) {
-                field = normalizeListFieldInPlace(field);
-                field = field.items;
-            }
-            if (isObjectField(field)) {
-                resolveThumbnailPathForModel(field, modelFilePath);
-            } else if (isEnumField(field)) {
-                resolveThumbnailPathForEnumField(field, modelFilePath);
-            }
-        });
-
-        const configModel = _.get(configModels, modelName);
-        if (!configModel) {
-            return modelFromFile;
-        }
-
-        return _.assign({}, modelFromFile, configModel, {
-            fields: _.unionBy(configModel?.fields ?? [], modelFromFile?.fields ?? [], 'name')
-        });
-    });
-    return Object.assign({}, configModels, mergedModels);
-}
-
-function mergeConfigWithExternalModels(config: any, externalModels?: Model[]): { config: any; errors: ConfigValidationError[] } {
+function mergeConfigWithExternalModels(config: RawConfigWithPaths, externalModels?: Model[]): { config: RawConfigWithPaths; errors: ConfigValidationError[] } {
     if (!externalModels || externalModels.length === 0) {
         return {
             config,
@@ -502,9 +461,14 @@ function normalizeConfig(config: any): any {
     const stackbitYamlVersion = String(_.get(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 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;
@@ -706,39 +670,6 @@ function addObjectTypeKeyField(model: any, objectTypeKey: string, modelName: str
     });
 }
 
-function resolveThumbnailPathForModel(modelOrField: Model | FieldObjectProps, modelFilePath: string | undefined) {
-    if (modelOrField.thumbnail && modelFilePath) {
-        const modelDirPath = path.dirname(modelFilePath);
-        modelOrField.thumbnail = resolveThumbnailPath(modelOrField.thumbnail, modelDirPath);
-    }
-}
-
-function resolveThumbnailPathForEnumField(enumField: FieldEnum, modelFilePath: string | undefined) {
-    if (enumField.controlType === 'thumbnails' && modelFilePath) {
-        const modelDirPath = path.dirname(modelFilePath);
-        _.forEach(enumField.options, (option) => {
-            if (option.thumbnail) {
-                option.thumbnail = resolveThumbnailPath(option.thumbnail, modelDirPath);
-            }
-        });
-    }
-}
-
-function resolveThumbnailPath(thumbnail: string, modelDirPath: string) {
-    if (thumbnail.startsWith('//') || /https?:\/\//.test(thumbnail)) {
-        return thumbnail;
-    }
-    if (thumbnail.startsWith('/')) {
-        if (modelDirPath.endsWith('@stackbit/components/models')) {
-            modelDirPath = modelDirPath.replace(/\/models$/, '');
-        } else {
-            modelDirPath = '';
-        }
-        thumbnail = thumbnail.replace(/^\//, '');
-    }
-    return path.join(modelDirPath, thumbnail);
-}
-
 /**
  * Returns model names referenced by polymorphic 'model' and 'reference' fields.
  * That is, fields that can hold objects of different types.
@@ -764,7 +695,7 @@ function getReferencedModelNames(field: any) {
     return referencedModelNames;
 }
 
-function validateAndExtendContentModels(config: any): ConfigValidationResult {
+function validateAndExtendContentModels(config: RawConfigWithPaths): ConfigValidationResult {
     const contentModels = config.contentModels ?? {};
     const models = config.models ?? {};
 
@@ -789,32 +720,35 @@ function validateAndExtendContentModels(config: any): ConfigValidationResult {
         };
     }
 
-    const extendedModels = _.mapValues(models, (model, modelName) => {
-        const contentModel = validationResult.value.contentModels[modelName];
-        if (!contentModel) {
-            return model;
-        }
-        if (_.get(contentModel, '__metadata.invalid')) {
-            return model;
-        }
-        if (contentModel.isPage && (!model.type || ['object', 'page'].includes(model.type))) {
-            return {
-                type: 'page',
-                ...(contentModel.newFilePath ? { filePath: contentModel.newFilePath } : {}),
-                ..._.omit(contentModel, ['isPage', 'newFilePath']),
-                ..._.omit(model, 'type')
-            };
-        } else if (!contentModel.isPage && (!model.type || ['object', 'data'].includes(model.type))) {
-            return {
-                type: 'data',
-                ...(contentModel.newFilePath ? { filePath: contentModel.newFilePath } : {}),
-                ..._.omit(contentModel, ['isPage', 'newFilePath']),
-                ..._.omit(model, 'type')
-            };
-        } else {
-            return model;
+    const extendedModels: ModelMap = _.mapValues(
+        models,
+        (model, modelName): YamlModel => {
+            const contentModel = validationResult.value.contentModels![modelName];
+            if (!contentModel) {
+                return model;
+            }
+            if (_.get(contentModel, '__metadata.invalid')) {
+                return model;
+            }
+            if (contentModel.isPage && (!model.type || ['object', 'page'].includes(model.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))) {
+                return {
+                    type: 'data',
+                    ...(contentModel.newFilePath ? { filePath: contentModel.newFilePath } : {}),
+                    ..._.omit(contentModel, ['isPage', 'newFilePath']),
+                    ..._.omit(model, 'type')
+                } as YamlModel;
+            } else {
+                return model;
+            }
         }
-    });
+    );
 
     return {
         valid: validationResult.valid,
@@ -833,7 +767,7 @@ function normalizeValidationResult(validationResult: ConfigValidationResult): No
 }
 
 function filterAndOrderConfigFields(validationResult: ConfigValidationResult): ConfigValidationResult {
-    // TODO: see if we move filtering and sorting to Joi
+    // TODO: check if we can move filtering and sorting to Joi
     return {
         ...validationResult,
         value: _.pick(validationResult.value, [
@@ -845,6 +779,9 @@ function filterAndOrderConfigFields(validationResult: ConfigValidationResult): C
             'buildCommand',
             'publishDir',
             'nodeVersion',
+            'postGitCloneCommand',
+            'preInstallCommand',
+            'postInstallCommand',
             'devCommand',
             'staticDir',
             'uploadDir',
@@ -859,12 +796,30 @@ function filterAndOrderConfigFields(validationResult: ConfigValidationResult): C
             'contentModels',
             'presetSource',
             'modelsSource',
+            'mapModels',
+            'presetReferenceBehavior',
+            'nonDuplicatableModels',
+            'duplicatableModels',
+            'contentSources',
+            'hcrHandled',
+            'internalStackbitRunnerOptions',
+            'dirPath',
+            'filePath',
             'models',
-            'presets'
-        ])
+            'presets',
+            'pageData', // obsolete, left for backward compatibility
+            'pageModels', // obsolete, left for backward compatibility
+            'encodedFieldTypes', // obsolete, left for backward compatibility
+            'noEncodeFields', // obsolete, left for backward compatibility
+            'omitFields' // obsolete, left for backward compatibility
+        ]) as RawConfigWithPaths
     };
 }
 
+/**
+ * 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 ?? {};
 
@@ -892,7 +847,7 @@ function convertModelGroupsToModelList(validationResult: ConfigValidationResult)
     });
 
     _.forEach(models, (model) => {
-        iterateModelFieldsRecursively(model, (field: any) => {
+        iterateModelFieldsRecursively(model as Model, (field: any) => {
             if (isListField(field)) {
                 field = field.items;
             }
@@ -921,11 +876,12 @@ function convertModelGroupsToModelList(validationResult: ConfigValidationResult)
 
 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 = config.models ?? {};
+    const modelMap = models ?? {};
     const modelArray: Model[] = _.map(
         modelMap,
         (yamlModel: YamlModel, modelName: string): Model => {
@@ -954,7 +910,8 @@ function convertModelsToArray(validationResult: ConfigValidationResult): Normali
     return {
         valid: validationResult.valid,
         config: {
-            ...config,
+            stackbitVersion,
+            ...rest,
             models: modelArray
         },
         errors: convertedErrors
@@ -974,6 +931,22 @@ function addImageModel(models: Model[]) {
     });
 }
 
-function isGitCMS(config: any) {
+function isGitCMS(config: RawConfigWithPaths) {
     return !config.cmsName || config.cmsName === 'git';
 }
+
+function getInternalStackbitRunnerOptions(config: any) {
+    const experimentalSsgData = _.get(config, 'experimental.ssg');
+    if (!experimentalSsgData) {
+        return _.get(config, '__unsafe_internal_stackbitRunnerOptions');
+    }
+    const doneStart = _.get(experimentalSsgData, 'logPatterns.up');
+    return {
+        displayName: experimentalSsgData.name || 'ssg',
+        triggerInstallFiles: _.get(experimentalSsgData, 'watch.reinstallPackages', ['package.json', 'package-lock.json']),
+        directPaths: experimentalSsgData.passthrough || [],
+        patterns: {
+            doneStart: _.isEmpty(doneStart) || _.isArray(doneStart) ? doneStart : [doneStart]
+        }
+    };
+}