@stackbit/sdk 0.2.39 → 0.3.1

package/src/config/config-loader-utils.ts

@@ -0,0 +1,253 @@
+import path from 'path';
+import fse from 'fs-extra';
+import yaml from 'js-yaml';
+import _ from 'lodash';
+
+import { parseFile, readDirRecursively, reducePromise, getFirstExistingFile } from '@stackbit/utils';
+
+import { ConfigLoadError, REFER_TO_STACKBIT_CONFIG_DOCS, STACKBIT_CONFIG_NOT_FOUND } from './config-errors';
+import { Config, FieldEnum, FieldObjectProps, Model, ModelMap, RawConfig, YamlModel } from './config-types';
+import { isEnumField, isListField, isObjectField, iterateModelFieldsRecursively, normalizeListFieldInPlace } from '../utils';
+
+export const STACKBIT_CONFIG_YAML_FILES = ['stackbit.yaml', 'stackbit.yml'];
+export const STACKBIT_CONFIG_JS_FILES = ['stackbit.config.js', 'stackbit.config.cjs', 'stackbit.config.mjs', 'stackbit.config.ts'];
+export const STACKBIT_CONFIG_FILES = [...STACKBIT_CONFIG_YAML_FILES, ...STACKBIT_CONFIG_JS_FILES];
+export const LATEST_STACKBIT_VERSION = '0.5.0';
+
+export type RawConfigWithPaths = RawConfig & {
+    dirPath: string;
+    filePath: string;
+};
+
+export type LoadRawConfigResult =
+    | {
+          config: RawConfig;
+          error: null;
+      }
+    | {
+          config: null;
+          error: ConfigLoadError;
+      };
+
+export type StopConfigWatch = {
+    stop?: () => void;
+    reload?: () => void;
+};
+
+export type LoadRawConfigResultWithStop = LoadRawConfigResult & StopConfigWatch;
+
+export type LoadRawConfigWithModelsResult = {
+    config?: RawConfig;
+    errors: ConfigLoadError[];
+};
+
+export async function loadConfigWithModelsFromDir(dirPath: string): Promise<LoadRawConfigWithModelsResult> {
+    const stackbitYamlPath = await getFirstExistingFile(STACKBIT_CONFIG_YAML_FILES, dirPath);
+    if (!stackbitYamlPath) {
+        return {
+            errors: [new ConfigLoadError(STACKBIT_CONFIG_NOT_FOUND)]
+        };
+    }
+    const stackbitYamlResult = await loadConfigFromStackbitYaml(stackbitYamlPath);
+    if (stackbitYamlResult.error) {
+        return {
+            errors: [stackbitYamlResult.error]
+        };
+    }
+    const { models: modelsFromFiles, errors: fileModelsErrors } = await loadYamlModelsFromFiles(dirPath, stackbitYamlResult.config);
+    const mergedModels = mergeConfigModelsWithModelsFromFiles(stackbitYamlResult.config.models ?? {}, modelsFromFiles);
+    return {
+        config: {
+            ...stackbitYamlResult.config,
+            models: mergedModels
+        },
+        errors: fileModelsErrors
+    };
+}
+
+export async function loadConfigFromStackbitYaml(stackbitYamlPath: string): Promise<LoadRawConfigResult> {
+    const stackbitYaml = await fse.readFile(stackbitYamlPath, 'utf8');
+    const config = yaml.load(stackbitYaml, { schema: yaml.JSON_SCHEMA });
+    if (!config || typeof config !== 'object') {
+        const fileName = path.basename(stackbitYamlPath);
+        return {
+            config: null,
+            error: new ConfigLoadError(`error parsing ${fileName}, ${REFER_TO_STACKBIT_CONFIG_DOCS}`)
+        };
+    }
+    return {
+        config,
+        error: null
+    };
+}
+
+export async function findStackbitConfigFile(dirs: string[]): Promise<string | null> {
+    for (const dir of dirs) {
+        for (const fileName of STACKBIT_CONFIG_FILES) {
+            const filePath = path.resolve(dir, fileName);
+            if (await fse.pathExists(filePath)) {
+                return filePath;
+            }
+        }
+    }
+    return null;
+}
+
+export function isStackbitYamlFile(filePath: string) {
+    const pathObject = path.parse(filePath);
+    return pathObject.base === 'stackbit.yaml' || pathObject.dir.split(path.sep).includes('.stackbit');
+}
+
+export function convertToYamlConfig({ config }: { config: Config }): RawConfig {
+    const yamlConfig: RawConfig = _.cloneDeep(_.omit(config, ['models', 'dirPath', 'filePath']));
+    if (!_.isEmpty(config.models)) {
+        yamlConfig.models = _.reduce(
+            config.models,
+            (yamlModels: ModelMap, model: Model) => {
+                if (model.type === 'image') {
+                    return yamlModels;
+                }
+                const yamlModel = _.omit(model, ['name', '__metadata']) as YamlModel;
+                if (yamlModel.type === 'page' && !yamlModel.hideContent && yamlModel.fields) {
+                    _.remove(yamlModel.fields, (field) => field.name === 'markdown_content');
+                }
+                if (yamlModel.type === 'page' && yamlModel.fields) {
+                    _.remove(yamlModel.fields, (field) => field.name === (config.pageLayoutKey || 'layout'));
+                }
+                if (yamlModel.type === 'data' && yamlModel.fields) {
+                    _.remove(yamlModel.fields, (field) => field.name === (config.objectTypeKey || 'type'));
+                }
+                yamlModels[model.name] = yamlModel;
+                return yamlModels;
+            },
+            {}
+        );
+    }
+    return yamlConfig;
+}
+
+async function loadYamlModelsFromFiles(dirPath: string, config: Partial<RawConfig>): 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 readYamlModelFilesFromDir(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 readYamlModelFilesFromDir(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);
+        }
+    });
+}
+
+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 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);
+}