@stackbit/sdk 0.2.30 → 0.2.33

package/src/config/config-loader.ts

@@ -6,6 +6,7 @@ import _ from 'lodash';
 
 import { ConfigValidationResult, validateConfig, validateContentModels } from './config-validator';
 import { ConfigError, ConfigLoadError, ConfigValidationError } from './config-errors';
+import { loadStackbitConfigFromJs, LoadStackbitConfigResult, StopConfigWatch } from './config-loader-esbuild';
 import {
     assignLabelFieldIfNeeded,
     extendModelMap,
@@ -25,13 +26,15 @@ import {
     normalizeListFieldInPlace,
     getModelFieldForModelKeyPath
 } from '../utils';
-import { append, prepend, omitByNil, parseFile, readDirRecursively, reducePromise, rename } from '@stackbit/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 { loadPresets } from './presets-loader';
 
 export interface ConfigLoaderOptions {
     dirPath: string;
     modelsSource?: ModelsSource;
+    stackbitConfigESBuildOutDir?: string;
+    watchCallback?: (result: ConfigLoaderResult) => void;
 }
 
 export interface ConfigLoaderResult {
@@ -46,13 +49,42 @@ export interface NormalizedValidationResult {
     errors: ConfigValidationError[];
 }
 
-export interface TempConfigLoaderResult {
+export interface RawConfigLoaderResult {
     config?: Record<string, any>;
     errors: ConfigLoadError[];
 }
 
-export async function loadConfig({ dirPath, modelsSource }: ConfigLoaderOptions): Promise<ConfigLoaderResult> {
-    const { config, errors: configLoadErrors } = await loadConfigFromDir(dirPath);
+export async function loadConfig({
+    dirPath,
+    modelsSource,
+    stackbitConfigESBuildOutDir,
+    watchCallback
+}: ConfigLoaderOptions): Promise<ConfigLoaderResult & StopConfigWatch> {
+    const rawConfigResult = await loadStackbitConfigFromDir({
+        dirPath,
+        stackbitConfigESBuildOutDir,
+        watchCallback: watchCallback
+            ? async (rawConfigResult: RawConfigLoaderResult) => {
+                  const configLoaderResult = await processConfigLoaderResult({ rawConfigResult, dirPath, modelsSource });
+                  watchCallback(configLoaderResult);
+              }
+            : undefined
+    });
+
+    const configLoaderResult = await processConfigLoaderResult({ rawConfigResult, dirPath, modelsSource });
+    return Object.assign(configLoaderResult, { stop: rawConfigResult.stop });
+}
+
+async function processConfigLoaderResult({
+    rawConfigResult,
+    dirPath,
+    modelsSource
+}: {
+    rawConfigResult: RawConfigLoaderResult;
+    dirPath: string;
+    modelsSource?: ModelsSource;
+}): Promise<ConfigLoaderResult> {
+    const { config, errors: configLoadErrors } = rawConfigResult;
 
     if (!config) {
         return {
@@ -107,41 +139,90 @@ export function validateAndNormalizeConfig(config: Record<string, any>, external
     });
 }
 
-async function loadConfigFromDir(dirPath: string): Promise<TempConfigLoaderResult> {
+async function loadStackbitConfigFromDir({
+    dirPath,
+    stackbitConfigESBuildOutDir,
+    watchCallback
+}: {
+    dirPath: string;
+    stackbitConfigESBuildOutDir?: string;
+    watchCallback?: (rawConfigResult: RawConfigLoaderResult) => void;
+}): Promise<RawConfigLoaderResult & StopConfigWatch> {
+    // try to load stackbit config from YAML files
     try {
-        const stackbitYamlResult = await loadConfigFromStackbitYaml(dirPath);
-        if (stackbitYamlResult.error) {
-            return { errors: [stackbitYamlResult.error] };
-        }
+        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 { models: modelsFromFiles, errors: fileModelsErrors } = await loadModelsFromFiles(dirPath, stackbitYamlResult.config);
+            const { models: modelsFromFiles, errors: fileModelsErrors } = await loadModelsFromFiles(dirPath, stackbitYamlResult.config);
 
-        const mergedModels = mergeConfigModelsWithModelsFromFiles(stackbitYamlResult.config.models ?? {}, modelsFromFiles);
+            const mergedModels = mergeConfigModelsWithModelsFromFiles(stackbitYamlResult.config.models ?? {}, modelsFromFiles);
 
+            return {
+                config: {
+                    ...stackbitYamlResult.config,
+                    models: mergedModels
+                },
+                errors: fileModelsErrors
+            };
+        }
+    } catch (error: any) {
         return {
-            config: {
-                ...stackbitYamlResult.config,
-                models: mergedModels
-            },
-            errors: fileModelsErrors
+            errors: [new ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })]
         };
+    }
+
+    function wrapResult(result: LoadStackbitConfigResult) {
+        if (result.error) {
+            return {
+                errors: [result.error]
+            };
+        } else {
+            return {
+                config: result.config,
+                errors: []
+            };
+        }
+    }
+
+    // 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);
+        if (configFilePath) {
+            const configResult = await loadStackbitConfigFromJs({
+                configPath: configFilePath,
+                outDir: stackbitConfigESBuildOutDir,
+                watch: !!watchCallback,
+                callback: watchCallback
+                    ? (result: LoadStackbitConfigResult) => {
+                          watchCallback(wrapResult(result));
+                      }
+                    : undefined
+            });
+            return Object.assign(wrapResult(configResult), { stop: configResult.stop });
+        }
     } catch (error: any) {
         return {
             errors: [new ConfigLoadError(`Error loading Stackbit configuration: ${error.message}`, { originalError: error })]
         };
     }
+
+    return {
+        errors: [
+            new ConfigLoadError(
+                'stackbit.yaml or stackbit.config.js was not found, please refer Stackbit documentation: https://www.stackbit.com/docs/stackbit-yaml/'
+            )
+        ]
+    };
 }
 
 type StackbitYamlConfigResult = { config: Record<string, any>; error?: never } | { config?: never; error: ConfigLoadError };
 
-async function loadConfigFromStackbitYaml(dirPath: string): Promise<StackbitYamlConfigResult> {
-    const stackbitYamlPath = path.join(dirPath, 'stackbit.yaml');
-    const stackbitYamlExists = await fse.pathExists(stackbitYamlPath);
-    if (!stackbitYamlExists) {
-        return {
-            error: new ConfigLoadError('stackbit.yaml was not found, please refer Stackbit documentation: https://www.stackbit.com/docs/stackbit-yaml/')
-        };
-    }
+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') {

package/src/config/config-schema.ts

@@ -300,7 +300,8 @@ const fieldGroupsSchema = Joi.array()
     .items(
         Joi.object<FieldGroupItem>({
             name: Joi.string().required(),
-            label: Joi.string().required()
+            label: Joi.string().required(),
+            icon: Joi.string().optional()
         })
     )
     .unique('name')
@@ -357,6 +358,10 @@ const enumFieldBaseOptionSchema = Joi.object({
     value: Joi.alternatives().try(Joi.string(), Joi.number()).required()
 });
 
+const imageFieldPartialSchema = Joi.object({
+    source: Joi.string()
+});
+
 const enumFieldPartialSchema = Joi.object({
     type: Joi.string().valid('enum').required(),
     controlType: Joi.string().valid('dropdown', 'button-group', 'thumbnails', 'palette'),
@@ -430,6 +435,7 @@ const listItemsSchema = Joi.object({
     switch: [
         { is: 'number', then: numberFieldPartialSchema },
         { is: 'enum', then: enumFieldPartialSchema },
+        { is: 'image', then: imageFieldPartialSchema },
         { is: 'object', then: objectFieldPartialSchema },
         { is: 'model', then: modelFieldPartialSchema },
         { is: 'reference', then: referenceFieldPartialSchema }
@@ -445,6 +451,7 @@ const fieldSchema: Joi.ObjectSchema<Field> = fieldCommonPropsSchema.when('.type'
     switch: [
         { is: 'number', then: numberFieldPartialSchema },
         { is: 'enum', then: enumFieldPartialSchema },
+        { is: 'image', then: imageFieldPartialSchema },
         { is: 'object', then: objectFieldPartialSchema },
         { is: 'model', then: modelFieldPartialSchema },
         { is: 'reference', then: referenceFieldPartialSchema },

package/src/config/config-types.ts

@@ -187,6 +187,7 @@ export interface BaseDataModeList extends Omit<BaseDataModel, 'fields'> {
 export interface FieldGroupItem {
     name: string;
     label: string;
+    icon?: string;
 }
 
 export interface ImageModel {
@@ -195,16 +196,18 @@ export interface ImageModel {
     label?: string;
     labelField?: string;
     fields?: Field[];
+    source?: string;
 }
 
 /*******************
  *** Field Types ***
  *******************/
 
-export type Field = FieldSimple | FieldEnum | FieldNumber | FieldObject | FieldModel | FieldReference | FieldStyle | FieldList;
+export type Field = FieldSimple | FieldEnum | FieldImage | FieldNumber | FieldObject | FieldModel | FieldReference | FieldStyle | FieldList;
 
 export type FieldSimple = FieldCommonProps & FieldSimpleProps;
 export type FieldEnum = FieldCommonProps & FieldEnumProps;
+export type FieldImage = FieldCommonProps & FieldImageProps;
 export type FieldNumber = FieldCommonProps & FieldNumberProps;
 export type FieldObject = FieldCommonProps & FieldObjectProps;
 export type FieldModel = FieldCommonProps & FieldModelProps;
@@ -232,7 +235,7 @@ export interface FieldCommonProps {
 export type FieldType = typeof FIELD_TYPES[number];
 
 export interface FieldSimpleProps {
-    type: 'string' | 'url' | 'slug' | 'text' | 'markdown' | 'html' | 'boolean' | 'date' | 'datetime' | 'color' | 'image' | 'file' | 'json' | 'richText';
+    type: 'string' | 'url' | 'slug' | 'text' | 'markdown' | 'html' | 'boolean' | 'date' | 'datetime' | 'color' | 'file' | 'json' | 'richText';
 }
 
 export type FieldEnumProps = FieldEnumDropdownProps | FieldEnumThumbnailsProps | FieldEnumPaletteProps;
@@ -272,6 +275,11 @@ export interface FieldEnumOptionPalette extends FieldEnumOptionObject {
     borderColor?: string;
 }
 
+export interface FieldImageProps {
+    type: 'image';
+    source?: string;
+}
+
 export interface FieldNumberProps {
     type: 'number';
     controlType?: 'slider';
@@ -315,4 +323,4 @@ export interface FieldListProps {
     items?: FieldListItems;
 }
 
-export type FieldListItems = FieldSimpleProps | FieldEnumProps | FieldNumberProps | FieldObjectProps | FieldModelProps | FieldReferenceProps;
+export type FieldListItems = FieldSimpleProps | FieldEnumProps | FieldImageProps | FieldNumberProps | FieldObjectProps | FieldModelProps | FieldReferenceProps;