@stackbit/sdk 0.3.13-alpha.0 → 0.3.13-alpha.1

package/src/config/config-loader.ts

@@ -4,11 +4,11 @@ import chokidar from 'chokidar';
 import semver from 'semver';
 import _ from 'lodash';
 
-import { ModelsSource, Field } from '@stackbit/types';
+import { ModelsSource, Field, ModelExtension, FieldExtension, FieldType } from '@stackbit/types';
 import { append, getFirstExistingFile, prepend, rename } from '@stackbit/utils';
 
-import { ConfigValidationResult, validateConfig, validateContentModels } from './config-validator';
-import { ConfigError, ConfigLoadError, ConfigValidationError, STACKBIT_CONFIG_NOT_FOUND } from './config-errors';
+import { ConfigValidationResult, validateBaseConfig, validateConfig, validateContentModels } from './config-validator';
+import { ConfigError, ConfigLoadError, ModelLoadError, ConfigValidationError, StackbitConfigNotFoundError } from './config-errors';
 import { loadStackbitConfigFromJs } from './config-loader-esbuild';
 import {
     assignLabelFieldIfNeeded,
@@ -65,14 +65,14 @@ export async function loadConfigWithModelsPresetsAndValidate({
         stackbitConfigESBuildOutDir,
         watchCallback: watchCallback
             ? async (configResult) => {
-                  const configLoaderResult = await processConfigLoaderResult({ configResult, dirPath, modelsSource });
+                  const configLoaderResult = await processConfigLoaderResult({ configResult, dirPath, modelsSource, logger });
                   watchCallback(configLoaderResult);
               }
             : undefined,
         logger
     });
 
-    const configLoaderResult = await processConfigLoaderResult({ configResult, dirPath, modelsSource });
+    const configLoaderResult = await processConfigLoaderResult({ configResult, dirPath, modelsSource, logger });
     return {
         ...configLoaderResult,
         stop: configResult.stop,
@@ -82,7 +82,7 @@ export async function loadConfigWithModelsPresetsAndValidate({
 
 export type ConfigWithModelsResult = {
     config: Config | null;
-    errors: (ConfigLoadError | ConfigValidationError)[];
+    errors: (ConfigLoadError | StackbitConfigNotFoundError | ModelLoadError | ConfigValidationError)[];
 };
 
 export async function loadConfigWithModels({
@@ -130,11 +130,11 @@ export async function loadConfigWithModels({
 export type LoadConfigResult =
     | {
           config: Config;
-          errors: ConfigLoadError[];
+          errors: ConfigValidationError[];
       }
     | {
           config: null;
-          errors: ConfigLoadError[];
+          errors: (ConfigLoadError | StackbitConfigNotFoundError)[];
       };
 
 export async function loadConfig({
@@ -156,11 +156,12 @@ export async function loadConfig({
             };
         }
 
-        // TODO: validate config base properties after normalizing and return validation errors
+        const validationResult = validateBaseConfig(rawConfigResult.config);
         const config = normalizeConfig(rawConfigResult.config);
+
         return {
             config: config,
-            errors: []
+            errors: validationResult.errors
         };
     };
 
@@ -188,11 +189,13 @@ export async function loadConfig({
 async function processConfigLoaderResult({
     configResult,
     dirPath,
-    modelsSource
+    modelsSource,
+    logger
 }: {
     configResult: ConfigWithModelsResult;
     dirPath: string;
     modelsSource?: ModelsSource;
+    logger?: Logger;
 }): Promise<ConfigWithModelsPresetsResult> {
     const { config, errors: configLoadErrors } = configResult;
 
@@ -206,7 +209,10 @@ async function processConfigLoaderResult({
 
     const { models: externalModels, errors: externalModelsLoadErrors } = await loadModelsFromExternalSource(config, dirPath, modelsSource);
 
-    const mergedModels = mergeConfigModelsWithExternalModels({ configModels: config.models, externalModels });
+    const mergedModels =
+        externalModels.length === 0
+            ? config.models
+            : mergeConfigModelsWithExternalModels({ configModels: config.models as ModelExtension[], externalModels, logger });
     const mergedConfig: Config = {
         ...config,
         models: mergedModels
@@ -234,8 +240,8 @@ async function processConfigLoaderResult({
     };
 }
 
-export async function loadAndMergeModelsFromFiles(config: Config): Promise<{ config: Config; errors: (ConfigLoadError | ConfigValidationError)[] }> {
-    const { models: modelsFromFiles, errors: fileModelsErrors } = await loadYamlModelsFromFiles(config);
+export async function loadAndMergeModelsFromFiles(config: Config): Promise<{ config: Config; errors: (ModelLoadError | ConfigValidationError)[] }> {
+    const { models: modelsFromFiles, errors: modelLoadErrors } = await loadYamlModelsFromFiles(config);
     const { models: mergedModels, errors: mergeModelErrors } = mergeConfigModelsWithModelsFromFiles(config.models, modelsFromFiles);
 
     const extendedConfig: Config = {
@@ -245,7 +251,7 @@ export async function loadAndMergeModelsFromFiles(config: Config): Promise<{ con
 
     return {
         config: extendedConfig,
-        errors: [...fileModelsErrors, ...mergeModelErrors]
+        errors: [...modelLoadErrors, ...mergeModelErrors]
     };
 }
 
@@ -277,7 +283,7 @@ export type RawConfigLoaderResult =
       }
     | {
           config: null;
-          error: ConfigLoadError;
+          error: ConfigLoadError | StackbitConfigNotFoundError;
       };
 
 export async function loadConfigFromDir({
@@ -397,7 +403,7 @@ export async function loadConfigFromDir({
 
     return {
         config: null,
-        error: new ConfigLoadError(STACKBIT_CONFIG_NOT_FOUND)
+        error: new StackbitConfigNotFoundError()
     };
 }
 
@@ -405,7 +411,7 @@ async function loadModelsFromExternalSource(
     config: Config,
     dirPath: string,
     modelsSource?: ModelsSource
-): Promise<{ models: Model[]; errors: ConfigLoadError[] }> {
+): Promise<{ models: Model[]; errors: ModelLoadError[] }> {
     modelsSource = _.assign({}, modelsSource, config.modelsSource);
     const sourceType = _.get(modelsSource, 'type', 'files');
     if (sourceType === 'files') {
@@ -424,13 +430,13 @@ async function loadModelsFromExternalSource(
         } catch (error: any) {
             return {
                 models: [],
-                errors: [new ConfigLoadError(`Error fetching and converting Contentful schema, error: ${error.message}`, { originalError: error })]
+                errors: [new ModelLoadError(`Error fetching and converting Contentful schema, error: ${error.message}`, { originalError: error })]
             };
         }
     }
     return {
         models: [],
-        errors: [new ConfigLoadError(`modelsSource ${modelsSource} is unsupported`)]
+        errors: [new ModelLoadError(`modelsSource ${modelsSource} is unsupported`)]
     };
 }
 
@@ -468,10 +474,15 @@ async function loadConfigFromDotStackbit(dirPath: string) {
     return _.isEmpty(config) ? null : config;
 }
 
-export function mergeConfigModelsWithExternalModels({ configModels, externalModels }: { configModels: Model[]; externalModels: Model[] }): Model[] {
-    if (externalModels.length === 0) {
-        return configModels;
-    }
+export function mergeConfigModelsWithExternalModels({
+    configModels,
+    externalModels,
+    logger
+}: {
+    configModels: ModelExtension[];
+    externalModels: Model[];
+    logger?: Logger;
+}): Model[] {
     if (configModels.length === 0) {
         return externalModels;
     }
@@ -489,7 +500,18 @@ export function mergeConfigModelsWithExternalModels({ configModels, externalMode
         let mergedModel: Model = Object.assign(
             {},
             externalModel,
-            _.pick(configModel, ['__metadata', 'urlPath', 'label', 'description', 'thumbnail', 'singleInstance', 'readOnly', 'labelField', 'fieldGroups']),
+            _.pick(configModel, [
+                '__metadata',
+                'urlPath',
+                'label',
+                'description',
+                'thumbnail',
+                'singleInstance',
+                'readOnly',
+                'labelField',
+                'fieldGroups',
+                'localized'
+            ]),
             { type: modelType }
         );
 
@@ -500,31 +522,66 @@ export function mergeConfigModelsWithExternalModels({ configModels, externalMode
         mergedModel = mapModelFieldsRecursively(
             mergedModel,
             (externalField, modelKeyPath): Field => {
-                const stackbitField = getModelFieldForModelKeyPath(configModel, modelKeyPath);
+                const stackbitField = getModelFieldForModelKeyPath(configModel as Model, modelKeyPath) as FieldExtension;
                 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']);
+                const FieldRemapMatrix: Record<string, FieldType[]> = {
+                    string: ['text', 'html', 'markdown', 'slug', 'url', 'color', 'date', 'datetime', 'enum', 'json', 'style'],
+                    text: ['html', 'markdown', 'json', 'style'],
+                    json: ['style']
+                };
+
+                // override field type if allowed, otherwise show a warning message
+                let fieldType: FieldType = externalField.type;
+                const allowedOverrideTypes = FieldRemapMatrix[externalField.type];
+                if (stackbitField.type && stackbitField.type !== externalField.type) {
+                    if (allowedOverrideTypes && allowedOverrideTypes.includes(stackbitField.type)) {
+                        fieldType = stackbitField.type;
+                    } else {
+                        logger?.warn(
+                            `Can't remap field of model '${mergedModel.name}' at path ${modelKeyPath}' ` +
+                                `from ${externalField.type}' type to '${stackbitField.type}' type. ` +
+                                `'${externalField.type}' fields can be only mapped to ` +
+                                (!allowedOverrideTypes
+                                    ? 'the same type.'
+                                    : allowedOverrideTypes.length === 1
+                                    ? `'${allowedOverrideTypes[0]}' type`
+                                    : `one of [${allowedOverrideTypes.join(', ')}] types.`)
+                        );
+                    }
+                }
+
+                // add field specific properties
+                let fieldSpecificProps = {};
+                switch (fieldType) {
+                    case 'number':
+                        fieldSpecificProps = _.pick(stackbitField, ['subtype', 'min', 'max', 'step', 'unit']);
+                        break;
+                    case 'enum':
+                        fieldSpecificProps = _.pick(stackbitField, ['options']);
+                        break;
+                    case 'style':
+                        fieldSpecificProps = _.pick(stackbitField, ['styles']);
+                        break;
+                    case 'object':
+                        fieldSpecificProps = _.pick(stackbitField, ['labelField', 'thumbnail', 'fieldGroups']);
+                        break;
+                    case 'model':
+                        fieldSpecificProps = _.pick(stackbitField, ['models']);
+                        break;
+                    case 'reference':
+                        fieldSpecificProps = _.pick(stackbitField, ['models']);
+                        break;
                 }
 
                 return Object.assign(
                     {},
                     externalField,
                     _.pick(stackbitField, ['label', 'description', 'required', 'default', 'group', 'const', 'hidden', 'readOnly', 'controlType']),
-                    override
+                    fieldSpecificProps,
+                    { type: fieldType }
                 );
             }
         );

package/src/config/config-schema.ts

@@ -22,6 +22,7 @@ import {
 import { CMS_NAMES, FIELD_TYPES, SSG_NAMES } from './config-consts';
 import { styleFieldPartialSchema } from './config-schema/style-field-schema';
 import { Config, Model, PageModel, ObjectModel, DataModel, ConfigModel } from './config-types';
+import { RawConfigWithPaths } from './config-loader-utils';
 
 function getConfigFromValidationState(state: Joi.State): Config {
     return _.last(state.ancestors)!;
@@ -139,12 +140,6 @@ function getModelNamesForGroup(group: string, config: Config) {
     );
 }
 
-const logicField = Joi.string();
-// TODO: validate that all logicFields reference existing fields
-// const logicField = Joi.custom((value) => {
-//     return value;
-// });
-
 const labelFieldNotFoundError = 'labelField.not.found';
 const labelFieldNotSimple = 'labelField.not.simple';
 const labelFieldSchema = Joi.custom((value, { error, state }) => {
@@ -645,7 +640,7 @@ const fieldNameUnique = 'field.name.unique';
 function errorLabelFromModelAndFieldPath(model: Model, modelIndex: number, fieldPath: (string | number | object)[]): string {
     let fieldSpecificProps: Model | FieldSpecificProps | undefined = model;
     let fields: Field[] | undefined;
-    let label = `models[${ model.name ? `name='${model.name}'` : modelIndex }]`;
+    let label = `models[${model.name ? `name='${model.name}'` : modelIndex}]`;
 
     for (const pathPart of fieldPath) {
         if (typeof pathPart === 'string') {
@@ -815,11 +810,14 @@ const sidebarButtonSchema = Joi.object({
     ]
 });
 
-export const stackbitConfigSchema = Joi.object<Config>({
+export const stackbitConfigBaseSchema = Joi.object<RawConfigWithPaths>({
     stackbitVersion: Joi.string().required(),
     ssgName: Joi.string().valid(...SSG_NAMES),
     ssgVersion: Joi.string(),
     nodeVersion: Joi.string(),
+    postGitCloneCommand: Joi.string(),
+    preInstallCommand: Joi.string(),
+    postInstallCommand: Joi.string(),
     devCommand: Joi.string(),
     cmsName: Joi.string().valid(...CMS_NAMES),
     import: importSchema,
@@ -832,17 +830,41 @@ export const stackbitConfigSchema = Joi.object<Config>({
     dataDir: Joi.string().allow('', null),
     pageLayoutKey: Joi.string().allow(null),
     objectTypeKey: Joi.string(),
-    styleObjectModelName: styleObjectModelNameSchema,
     excludePages: Joi.array().items(Joi.string()).single(),
-    logicFields: Joi.array().items(logicField),
+    styleObjectModelName: Joi.string(),
+    logicFields: Joi.array().items(Joi.string()),
     contentModels: Joi.any(), // contentModels should have been already validated by now
-    sidebarButtons: Joi.array().items(sidebarButtonSchema),
     presetSource: presetSourceSchema,
     modelsSource: modelsSourceSchema,
-    models: modelsSchema
+    sidebarButtons: Joi.array().items(sidebarButtonSchema),
+    models: Joi.any(),
+    modelExtensions: Joi.array().items(Joi.any()),
+    presetReferenceBehavior: Joi.string().valid('copyReference', 'duplicateContents'),
+    nonDuplicatableModels: Joi.array().items(Joi.string()).when('presetReferenceBehavior', {
+        is: 'copyReference',
+        then: Joi.forbidden()
+    }),
+    duplicatableModels: Joi.array().items(Joi.string()).when('presetReferenceBehavior', {
+        is: 'duplicateContents',
+        then: Joi.forbidden()
+    }),
+    customContentReload: Joi.boolean(),
+    experimental: Joi.any(),
+    contentSources: Joi.array().items(Joi.any()),
+    siteMap: Joi.function(),
+    mapModels: Joi.function(),
+    // internal properties added by load
+    dirPath: Joi.string(),
+    filePath: Joi.string()
 })
-    .unknown(true)
     .without('assets', ['staticDir', 'uploadDir'])
+    .without('contentSources', ['cmsName', 'assets', 'contentModels', 'modelsSource'])
+    .when('.modelExtensions', {
+        is: Joi.exist(),
+        then: Joi.object({
+            models: Joi.forbidden()
+        })
+    })
     .when('.cmsName', {
         is: ['contentful', 'sanity'],
         then: Joi.object({
@@ -853,5 +875,13 @@ export const stackbitConfigSchema = Joi.object<Config>({
             dataDir: Joi.forbidden(),
             excludePages: Joi.forbidden()
         })
+    });
+
+export const stackbitConfigFullSchema = stackbitConfigBaseSchema.concat(
+    Joi.object<Config>({
+        styleObjectModelName: styleObjectModelNameSchema,
+        models: modelsSchema
     })
-    .shared(fieldsSchema);
+        .unknown(true)
+        .shared(fieldsSchema)
+);

package/src/config/config-validator.ts

@@ -1,8 +1,8 @@
 import _ from 'lodash';
 import Joi from 'joi';
-import { ContentModelMap } from '@stackbit/types';
+import { ContentModelMap, StackbitConfig } from '@stackbit/types';
 
-import { contentModelsSchema, stackbitConfigSchema } from './config-schema';
+import { contentModelsSchema, stackbitConfigBaseSchema, stackbitConfigFullSchema } from './config-schema';
 import { ConfigValidationError } from './config-errors';
 import { Config, Model } from './config-types';
 
@@ -12,9 +12,26 @@ export interface ConfigValidationResult {
     errors: ConfigValidationError[];
 }
 
+export function validateBaseConfig(
+    config: StackbitConfig
+): {
+    config: StackbitConfig;
+    valid: boolean;
+    errors: ConfigValidationError[];
+} {
+    const validationOptions = { abortEarly: false, context: { config: config } };
+    const validationResult = stackbitConfigBaseSchema.validate(config, validationOptions);
+    const errors = mapJoiErrorsToConfigValidationErrors(validationResult);
+    return {
+        config: validationResult.value,
+        valid: _.isEmpty(errors),
+        errors
+    };
+}
+
 export function validateConfig(config: Config): ConfigValidationResult {
     const validationOptions = { abortEarly: false, context: { config: config } };
-    const validationResult = stackbitConfigSchema.validate(config, validationOptions);
+    const validationResult = stackbitConfigFullSchema.validate(config, validationOptions);
     const validatedConfig: Config = validationResult.value;
     const errors = mapJoiErrorsToConfigValidationErrors(validationResult);
     const valid = _.isEmpty(errors);
@@ -41,15 +58,12 @@ export interface ContentModelsValidationResult {
 export function validateContentModels(contentModels: ContentModelMap, models: Model[]): ContentModelsValidationResult {
     const modelMap: Record<string, Model> = _.keyBy(models, 'name');
     const config = { contentModels: contentModels };
-    const validationResult = contentModelsSchema.validate(
-        config,
-        {
-            abortEarly: false,
-            context: {
-                modelMap: modelMap
-            }
+    const validationResult = contentModelsSchema.validate(config, {
+        abortEarly: false,
+        context: {
+            modelMap: modelMap
         }
-    );
+    });
     const validatedConfig: Config = validationResult.value;
     const errors = mapJoiErrorsToConfigValidationErrors(validationResult);
     const valid = _.isEmpty(errors);